leptris 1.9.121.0 → 1.9.144.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85000791341954ae6ac1ad4b81236ad657e0c9d3dad1914ce182de881e8631ef
-  data.tar.gz: 55657d439219c20317b1a0c66916817cb131d502a25120cbc9566bd4d17e7c0e
+  metadata.gz: ce24363303ca7b04d2cc2862985a5db2a2358e03910cac76f1fc21c417a84ed5
+  data.tar.gz: 97f81edbb20997881c632c369eda7c2d2cb219582cd9e19cf8b0e458855c4a4c
 SHA512:
-  metadata.gz: fe1948ea43444c5057909c2a53e9cc2e3f0682db71a46ead7be72cccc65051036c568bd560615ed6426c8da3b5a074f33bd6a222eb3dc0734d4a8da72e9ec33b
-  data.tar.gz: '088636076490098a9e58a964f45d06a0bc21cd78d5164df2fa04a69f194a0540cfeb9309af95ea9fd67e518533c7c006eb018b84b5de14a9d4266153dfba4a27'
+  metadata.gz: 06622c78d7f4ed9cfcf8aae54f696d237f819d5d33f0875f2b3145e63b624f837c45fb7b160dc2e5c11de23ea95db7cfffbdc49ea04d5f0087f7e04cfb57fb23
+  data.tar.gz: 23e5b135a9146e96d7d452255e6ff7d77d875285c687bd58af6c6276486b5c161e1c82911ca90a419f72422eae7cb2f538e609451d2b9882ce7bb31464dbb95b

data/CHANGELOG.md

@@ -5,6 +5,58 @@ 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.144.0] - 2026-09-12
+
+### Changed
+
+- **Lockstep with libleptris 1.9.144** (1.9.121 → 1.9.144; audit
+  270 → 289 after attaching 19 new symbols).
+- **`Leptris::XML::Schematron`** — ISO Schematron validation
+  (libleptris 1.9.127/1.9.128; schematron-conformance corpus
+  50/50): `Schematron.parse(schema_xml, phase: nil)` / `.parse_file`
+  compile once, then `#valid?(doc)` answers the boolean and
+  `#validate(doc)` returns the SVRL report as a queryable
+  `Document` (failed-assert / successful-report with @location).
+- **`Leptris::XML::Diff`** — native tree diff (libleptris
+  1.9.127, namespace-aware 1.9.129): `Leptris::XML.diff(a, b,
+  ignore_ws: false)` → `#ops` (`{type:, name:, path:, before:,
+  after:}`; insert/delete/update_text/update_attr with
+  positional `/name[i]` paths) and `#to_s` (the serialized op
+  list); `Diff.identical?(a, b, ignore_ws:)` answers the boolean
+  fast path.
+- **XQuery external variables** (libleptris 1.9.133) —
+  `XQuery#eval(doc, params)` binds `declare variable $x external`
+  through `leptris_xquery_eval_params` with QT3 `<param select>`
+  semantics (each value is an XPath expression in an empty
+  context); a binding overrides a default initializer, and an
+  empty params hash takes the same lane — the engine decides
+  between the default and failure.
+- **`Element#expanded_name`** (libleptris 1.9.144) —
+  `{local:, prefix:, namespace_uri:}` in one C call.
+- **`#xpath_versioned(expression, version)`** — version-pinned
+  evaluation via `leptris_xpath_eval_versioned`: `:xpath10`
+  keeps the strict 1.0 surface (3.x syntax raises), `:xpath31`
+  evaluates the full grammar. A separate method by design —
+  `#xpath`'s trailing-hash argument is the namespace-binding
+  channel.
+- **`Node#digest(drop_ws:)`** — the #869 content-defined Merkle
+  digest behind diff pruning.
+- **Serialization: `to_xml(..., expand_empty:)`** — the
+  `<e></e>` vs `<e/>` switch at the C seam.
+- Engine arc: the W3C QT3 suite adoption (fn/substring 45/45,
+  fn/contains 41/41, fn/starts-with 43/43, fn/ends-with 34/34,
+  fn/concat 80/80 — int64 integer fidelity keeps
+  `xs:integer('999999999999999999')` exact) and the WHATWG HTML
+  completion arc (frameset, in-head-noscript, character
+  references, comment close forms, **full adoption agency**
+  1.9.137 — `"<h1>a<h2>b</h1>c</h2>"` now yields
+  `<h1>a</h1><h2>b</h2>c` per the spec — initial-mode comment
+  placement, in-head comments, foreign-content integration
+  scopes, in-table clear-stack, script-data escapes, RCDATA/
+  rawtext, numeric-reference end states; html5lib floor
+  928 → 933). #965: relational comparisons no longer swap
+  operands (`10 >= @n` compares as written).
+
 ## [1.9.115.0] - 2026-09-09
 
 ### 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.121"
+LIBLEPTRIS_VERSION = "1.9.144"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.121.0"
+  VERSION = "1.9.144.0"
 end

data/lib/leptris/xml/diff.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+# Tree diff between two documents (libleptris >= 1.9.126):
+# equal subtrees prune in O(1) via the #869 content-defined Merkle
+# digest; diverging regions align through an LCS on child digests,
+# then same-named elements recurse. Attribute add/remove are
+# UPDATE_ATTR ops with an empty side.
+#
+#     diff = Leptris::XML.diff(before_doc, after_doc)
+#     diff.ops    # => [{type: :update_text, name: "price",
+#                    #      path: "/r/item[2]/price", before: "3", after: "4"}, ...]
+#     diff.to_s   # => serialized op list
+#     Leptris::XML.diff(a, b, ignore_ws: true)  # ws-only text absent
+#
+class Leptris::XML::Diff
+  class Handle < ::FFI::AutoPointer
+    def self.release(ptr)
+      Leptris::XML::FFI.leptris_diff_free(ptr)
+    end
+  end
+
+  OP_TYPES = {
+    1 => :insert,
+    2 => :delete,
+    3 => :update_text,
+    4 => :update_attr,
+  }.freeze
+  private_constant :OP_TYPES
+
+  def self.compute(document_a, document_b, ignore_ws: false)
+    flags = ignore_ws ? 1 : 0
+    raw = Leptris::XML::FFI.leptris_diff(
+      document_a.c_ptr, document_b.c_ptr, flags, nil)
+    if raw.null?
+      raise Leptris::XML::Error,
+        "leptris_diff failed: #{Leptris::XML::FFI.leptris_last_error}"
+    end
+    new(Handle.new(raw))
+  end
+
+  # The boolean fast path canon-style consumers want: are the two
+  # trees structurally identical? Zero ops == identical — the
+  # digest pruning makes the common equal case O(1) per subtree.
+  def self.identical?(document_a, document_b, ignore_ws: false)
+    compute(document_a, document_b, ignore_ws: ignore_ws).ops.empty?
+  end
+
+  def initialize(handle)
+    @handle = handle
+  end
+
+  # The op list in document order: {type:, name:, path:, before:,
+  # after:} — paths are root-relative ("/r/i[2]"); before/after
+  # carry payloads (attribute values / text) where the op has them.
+  def ops
+    count = Leptris::XML::FFI.leptris_diff_op_count(@handle)
+    Array.new(count) do |i|
+      {
+        type: OP_TYPES[Leptris::XML::FFI.leptris_diff_op_type(@handle, i)],
+        name: Leptris::XML::FFI.leptris_diff_op_name(@handle, i),
+        path: Leptris::XML::FFI.leptris_diff_op_path(@handle, i),
+        before: Leptris::XML::FFI.leptris_diff_op_before(@handle, i),
+        after: Leptris::XML::FFI.leptris_diff_op_after(@handle, i),
+      }
+    end
+  end
+
+  def to_s
+    str_ptr = Leptris::XML::FFI.leptris_diff_serialize(@handle)
+    Leptris::XML::FFI.read_owned_string(str_ptr)
+  end
+end

data/lib/leptris/xml/element.rb

@@ -341,6 +341,30 @@ class Leptris::XML::Element < Leptris::XML::Node
     uri
   end
 
+  # The local name, prefix, and resolved namespace URI in ONE
+  # call (libleptris 1.9.144) — the adapter fan-out read.
+  # Equivalent to #name + #prefix + #namespace, single entry.
+  def expanded_name
+    ensure_alive!
+    local = ::FFI::MemoryPointer.new(:pointer)
+    prefix = ::FFI::MemoryPointer.new(:pointer)
+    uri = ::FFI::MemoryPointer.new(:pointer)
+    Leptris::XML::FFI.leptris_element_expanded_name(
+      @c_ptr, local, prefix, uri)
+    local_ptr = local.read_pointer
+    prefix_ptr = prefix.read_pointer
+    uri_ptr = uri.read_pointer
+    result = {
+      local: local_ptr.read_string,
+      prefix: prefix_ptr.null? ? nil : prefix_ptr.read_string,
+      namespace_uri: uri_ptr.null? ? nil : uri_ptr.read_string,
+    }
+    local.free
+    prefix.free
+    uri.free
+    result
+  end
+
   def namespace_definitions
     return @namespace_definitions if memo_hit?(@namespace_definitions_version)
     ensure_alive!

data/lib/leptris/xml/ffi.rb

@@ -64,6 +64,8 @@ module Leptris
       typedef :pointer, :leptris_relaxng
       typedef :pointer, :leptris_xslt
       typedef :pointer, :leptris_xquery
+      typedef :pointer, :leptris_schematron
+      typedef :pointer, :leptris_diff
       typedef :pointer, :leptris_sax_recorder
       typedef :pointer, :leptris_pull_parser
       typedef :pointer, :leptris_iterparse
@@ -744,8 +746,72 @@ attach_function :leptris_parse_string,
       attach_function :leptris_xquery_eval,
         [:leptris_xquery, :leptris_document, :leptris_element],
         :leptris_xpath_result
+      # External-variable XQuery evaluation (libleptris 1.9.133):
+      # names[i]/selects[i] bind `declare variable $name external`
+      # — each select is an XPath expression in an empty context
+      # (QT3 <param select> semantics), overriding any default
+      # initializer. An external with neither binding nor default
+      # fails evaluation.
+      attach_function :leptris_xquery_eval_params,
+        [:leptris_xquery, :leptris_document, :leptris_element,
+         :pointer, :pointer, :size_t], :leptris_xpath_result
       attach_function :leptris_xquery_free, [:leptris_xquery], :void
 
+      # Schematron validation (libleptris >= 1.9.126 family):
+      # parse once (optionally selecting a PHASE), validate any
+      # number of documents — #validate returns the SVRL report as
+      # a Document; #valid? answers through the SVRL root name.
+      attach_function :leptris_schematron_parse,
+        [:string, :size_t, :pointer], :leptris_schematron
+      attach_function :leptris_schematron_parse_file,
+        [:string, :pointer], :leptris_schematron
+      attach_function :leptris_schematron_parse_phase,
+        [:string, :size_t, :string, :pointer], :leptris_schematron
+      attach_function :leptris_schematron_free,
+        [:leptris_schematron], :void
+      attach_function :leptris_schematron_valid,
+        [:leptris_schematron, :leptris_document], :int
+      attach_function :leptris_schematron_validate,
+        [:leptris_schematron, :leptris_document], :leptris_document
+      attach_function :leptris_schematron_error,
+        [:leptris_schematron], :string
+
+      # Tree diff (libleptris >= 1.9.126 family): equal subtrees
+      # prune in O(1) by the #869 Merkle digest; diverging regions
+      # align via LCS on child digests, then recurse by name.
+      attach_function :leptris_diff,
+        [:leptris_document, :leptris_document, :int, :pointer],
+        :leptris_diff
+      attach_function :leptris_diff_free, [:leptris_diff], :void
+      attach_function :leptris_diff_op_count, [:leptris_diff], :size_t
+      attach_function :leptris_diff_op_type,
+        [:leptris_diff, :size_t], :int
+      attach_function :leptris_diff_op_name,
+        [:leptris_diff, :size_t], :string
+      attach_function :leptris_diff_op_path,
+        [:leptris_diff, :size_t], :string
+      attach_function :leptris_diff_op_before,
+        [:leptris_diff, :size_t], :string
+      attach_function :leptris_diff_op_after,
+        [:leptris_diff, :size_t], :string
+      attach_function :leptris_diff_serialize,
+        [:leptris_diff], :pointer
+
+      # One-call expanded name (libleptris 1.9.144): local name +
+      # prefix + resolved namespace URI in a single entry — the
+      # FFI-adapter fan-out read.
+      attach_function :leptris_element_expanded_name,
+        [:leptris_element, :pointer, :pointer, :pointer], :void
+
+      # Versioned XPath evaluation (libleptris lane 15): XPATH_10
+      # keeps the strict 1.0 surface (3.x syntax rejected with
+      # INVALID_ARG); XPATH_31 evaluates the full grammar.
+      attach_function :leptris_xpath_eval_versioned,
+        [:leptris_document, :leptris_element, :string, :int, :pointer],
+        :leptris_xpath_result
+      XPATH_10 = 1 # strict XPath 1.0: the 3.x surface is rejected
+      XPATH_31 = 3 # the full grammar (the default entry's surface)
+
       # One-pass entity pre-scan (libleptris 1.9.62, leptris#745):
       # 1 when the buffer holds a named entity that is not one of
       # the five predefined XML entities (nor numeric) — the moxml

data/lib/leptris/xml/schematron.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Leptris::XML::Schematron
+  module_function
+
+  def parse(schema_xml, phase: nil)
+    Schema.parse(schema_xml, phase: phase)
+  end
+
+  def parse_file(path, phase: nil)
+    Schema.parse_file(path, phase: phase)
+  end
+
+  # A compiled Schematron schema (libleptris >= 1.9.126): parse
+  # once — optionally selecting a PHASE, which activates only its
+  # patterns — then validate any number of documents. #validate
+  # returns the SVRL report as a queryable Document; #valid?
+  # answers the boolean.
+  #
+  #     sch = Leptris::XML::Schematron.parse(schema_xml)
+  #     sch.valid?(doc)      # => true/false
+  #     svrl = sch.validate(doc)   # => Document (svrl:schema root)
+  #     sch = Leptris::XML::Schematron.parse(schema_xml, phase: "Basic")
+  #
+  class Schema
+    class Handle < ::FFI::AutoPointer
+      def self.release(ptr)
+        Leptris::XML::FFI.leptris_schematron_free(ptr)
+      end
+    end
+
+    def self.parse(schema_xml, phase: nil)
+      xml = schema_xml.to_s
+      raw =
+        if phase
+          Leptris::XML::FFI.leptris_schematron_parse_phase(
+            xml, xml.bytesize, phase.to_s, nil)
+        else
+          Leptris::XML::FFI.leptris_schematron_parse(xml, xml.bytesize, nil)
+        end
+      if raw.null?
+        raise Leptris::XML::Error,
+          "schema parse failed: #{Leptris::XML::FFI.leptris_last_error}"
+      end
+      new(Handle.new(raw))
+    end
+
+    def self.parse_file(path, phase: nil)
+      raw =
+        if phase
+          xml = File.read(path)
+          Leptris::XML::FFI.leptris_schematron_parse_phase(
+            xml, xml.bytesize, phase.to_s, nil)
+        else
+          Leptris::XML::FFI.leptris_schematron_parse_file(path.to_s, nil)
+        end
+      if raw.null?
+        raise Leptris::XML::Error,
+          "schema parse failed: #{Leptris::XML::FFI.leptris_last_error}"
+      end
+      new(Handle.new(raw))
+    end
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    # The SVRL report as a Document (svrl:schema root — query
+    # failed-assert / successful-report elements like any other
+    # tree), or the schema-level error text.
+    def validate(document)
+      report = Leptris::XML::FFI.leptris_schematron_validate(
+        @handle, document.c_ptr)
+      if report.null?
+        Leptris::XML::FFI.leptris_schematron_error(@handle)
+      else
+        Leptris::XML::Document.wrap(report)
+      end
+    end
+
+    def valid?(document)
+      Leptris::XML::FFI.leptris_schematron_valid(
+        @handle, document.c_ptr) != 0
+    end
+  end
+end

data/lib/leptris/xml/searchable.rb

@@ -85,6 +85,27 @@ module Leptris::XML::Searchable
     at_xpath(expr)
   end
 
+  # Version-pinned evaluation (libleptris lane 15,
+  # leptris_xpath_eval_versioned): :xpath10 keeps the strict XPath
+  # 1.0 surface — 3.x syntax (arrow, bang, lookup, let, inline
+  # functions, string templates) raises; :xpath31 evaluates the
+  # full grammar (identical to #xpath's default entry). A separate
+  # method by design: #xpath's trailing-hash argument is the
+  # namespace-binding channel, and a declared keyword would
+  # capture it.
+  def xpath_versioned(expression, version)
+    doc_ptr = is_a?(Leptris::XML::Document) ? c_ptr : document.c_ptr
+    context_ptr = is_a?(Leptris::XML::Document) ? nil : c_ptr
+    result_ptr = Leptris::XML::FFI.leptris_xpath_eval_versioned(
+      doc_ptr, context_ptr, expression,
+      Leptris::XML::Searchable.xpath_version_code(version), nil)
+    if result_ptr.null?
+      raise Leptris::XML::XPathError,
+        Leptris::XML::FFI.leptris_last_error.to_s
+    end
+    Leptris::XML::Searchable.wrap_xpath_result(document, result_ptr)
+  end
+
   protected
 
   # Evaluates against a caller-owned namespace binding set; the
@@ -95,6 +116,21 @@ module Leptris::XML::Searchable
     end
   end
 
+
+  # Version pin for xpath_versioned: :xpath10
+  # keeps the strict XPath 1.0 surface (3.x syntax — arrow, bang,
+  # lookup, let, inline functions — raises); :xpath31 evaluates the
+  # full grammar (identical to the default entry).
+  def self.xpath_version_code(version)
+    case version
+    when :xpath10, "1.0" then Leptris::XML::FFI::XPATH_10
+    when :xpath31, "3.1" then Leptris::XML::FFI::XPATH_31
+    else
+      raise ArgumentError,
+        "version must be :xpath10 or :xpath31, got #{version.inspect}"
+    end
+  end
+
   def parse_search_args(args)
     handler = args.find { |a| !a.is_a?(String) && !a.is_a?(Hash) && !a.is_a?(Symbol) }
     args = args - [handler] if handler

data/lib/leptris/xml/xquery.rb

@@ -46,10 +46,28 @@ class Leptris::XML::XQuery
   # FLWOR results arrive as the sequence channel — read them through
   # an aggregate until the engine materializes readable sequence
   # items (same caveat as the XPath for-return subset).
-  def eval(doc_or_element)
+  # +params+ binds external variables (libleptris 1.9.133): each
+  # value is an XPath expression evaluated in an empty context
+  # (QT3 <param select> semantics) — {"x" => "21 * 2"} binds
+  # `declare variable $x external`. A binding overrides the
+  # declaration's default initializer; an external with neither
+  # fails evaluation. An empty params hash takes the same lane —
+  # the engine decides between default initializer and failure.
+  def eval(doc_or_element, params = nil)
     context = Leptris::XML::EvaluationContext.of(doc_or_element)
-    result_ptr = Leptris::XML::FFI.leptris_xquery_eval(
-      @handle, context.document.c_ptr, context.context_node_ptr)
+    result_ptr =
+      if params
+        names, name_anchors = Leptris::XML::CStringArray.to_c(
+          params.keys.map(&:to_s))
+        selects, select_anchors = Leptris::XML::CStringArray.to_c(
+          params.values.map(&:to_s))
+        Leptris::XML::FFI.leptris_xquery_eval_params(
+          @handle, context.document.c_ptr, context.context_node_ptr,
+          names, selects, params.size)
+      else
+        Leptris::XML::FFI.leptris_xquery_eval(
+          @handle, context.document.c_ptr, context.context_node_ptr)
+      end
     if result_ptr.null?
       raise Leptris::XML::XPathError,
         Leptris::XML::FFI.leptris_last_error.to_s

data/lib/leptris/xml.rb

@@ -23,6 +23,8 @@ module Leptris
     autoload :SAX, "leptris/xml/sax"
     autoload :XPath, "leptris/xml/xpath"
     autoload :EvaluationContext, "leptris/xml/evaluation_context"
+    autoload :Schematron, "leptris/xml/schematron"
+    autoload :Diff, "leptris/xml/diff"
     autoload :IterationScope, "leptris/xml/iteration_scope"
     autoload :ResultText, "leptris/xml/result_text"
     autoload :ResultAttr, "leptris/xml/result_attr"
@@ -39,6 +41,14 @@ module Leptris
                      recover: recover)
     end
 
+    # Tree diff between two documents: equal subtrees prune in
+    # O(1) by content digest; diverging regions align by LCS.
+    # +ignore_ws+ treats whitespace-only text nodes as absent.
+    def self.diff(document_a, document_b, ignore_ws: false)
+      Leptris::XML::Diff.compute(document_a, document_b,
+                                 ignore_ws: ignore_ws)
+    end
+
     # Does +string+ contain a named entity reference that is not
     # one of the five predefined XML entities (nor numeric)? One C
     # pass (libleptris 1.9.62) — downstream adapters use it to skip

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.121.0
+  version: 1.9.144.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-09 00:00:00.000000000 Z
+date: 2026-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -106,6 +106,7 @@ files:
 - lib/leptris/xml/cdata.rb
 - lib/leptris/xml/comment.rb
 - lib/leptris/xml/css_to_xpath.rb
+- lib/leptris/xml/diff.rb
 - lib/leptris/xml/doc_type.rb
 - lib/leptris/xml/document.rb
 - lib/leptris/xml/document_fragment.rb
@@ -128,6 +129,7 @@ files:
 - lib/leptris/xml/sax/dom_dispatch.rb
 - lib/leptris/xml/sax/parser.rb
 - lib/leptris/xml/sax/recorder.rb
+- lib/leptris/xml/schematron.rb
 - lib/leptris/xml/searchable.rb
 - lib/leptris/xml/serialization.rb
 - lib/leptris/xml/text.rb