leptris 1.9.121.0 → 1.9.144.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85000791341954ae6ac1ad4b81236ad657e0c9d3dad1914ce182de881e8631ef
-  data.tar.gz: 55657d439219c20317b1a0c66916817cb131d502a25120cbc9566bd4d17e7c0e
+  metadata.gz: '01429a81e019ba9e4ecf9d2a7c23ada3b4d2c6dc3849c5a0be469bbab52b5c92'
+  data.tar.gz: 21bc4d37174f592fe72821f9fd7074eb7521c7ff4eacad42141720f2e235c97b
 SHA512:
-  metadata.gz: fe1948ea43444c5057909c2a53e9cc2e3f0682db71a46ead7be72cccc65051036c568bd560615ed6426c8da3b5a074f33bd6a222eb3dc0734d4a8da72e9ec33b
-  data.tar.gz: '088636076490098a9e58a964f45d06a0bc21cd78d5164df2fa04a69f194a0540cfeb9309af95ea9fd67e518533c7c006eb018b84b5de14a9d4266153dfba4a27'
+  metadata.gz: 181136f9e8da6a067bba876bbbfe5e841c062470fce5c6a521de413f5abd4a33d824eb387155021b486ff5063e70d96077156b79656440ee418d4b388bc5297c
+  data.tar.gz: 3e088d8220ec7c3c40f4e9869caf8cc73e08606ac4f7035a9f8a277454fafc1d7921c11fe17aa64f4c328254362103962bf05218385e1855c27fad3663b5b915

data/CHANGELOG.md

@@ -5,6 +5,93 @@ 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.1] - 2026-09-12
+
+### Fixed
+
+- **#161 (DOM parity for engine porters)**:
+  - `Node#dup` works for every node kind — text, comment, CDATA,
+    and PI rebuild by value through the document factories behind
+    the same `Document.copy_of` seam (elements keep the C deep
+    copy); previously `dup` raised "only supported for element
+    nodes".
+  - `Element#[]` and `#key?` read back qualified attribute names
+    the namespace-aware engine lookup misses (a value written as
+    `el["n:x"] = "9"` with an undeclared prefix now answers
+    `el["n:x"]` — the written-name face `#attributes` exposes);
+    declared-prefix reads are unchanged.
+  - `Element#qualified_name` — the written spelling ("p:c" /
+    "c") behind the `#name`/`#prefix` split.
+  - `to_xml(indent:)` was already documented in the README
+    serialization section — no change needed.
+
+### Added
+
+- **XPATH_FUNCTION result mirror** (PR #127, libleptris TODO 07
+  lane): the type-4 constant is attached and `wrap_xpath_result`
+  raises an explicit, actionable error when an XPath 3.0 function
+  item would cross the FFI boundary (`concat#2`) instead of the
+  generic "unknown xpath result type 4".
+
+### Documentation
+
+- **#160**: README "Alternative engines" section — the plain
+  `ruby`-platform gem ships with every release, so TruffleRuby and
+  JRuby activate leptris via FFI; the section documents the
+  system-library / `LEPTRIS_LIB_PATH` path those engines need.
+
+## [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/README.adoc

@@ -60,6 +60,21 @@ export LEPTRIS_LIB_PATH=/usr/local/lib/libleptris.dylib
 If Leptris can't find the library at startup, every `parse` call raises
 `LoadError`.
 
+=== Alternative engines: TruffleRuby and JRuby (#160)
+
+The gem ships a plain `ruby`-platform variant alongside the precompiled
+platform gems, so Bundler activates `leptris` on TruffleRuby and JRuby
+(the binding is FFI-based — no MRI C extension anywhere). Those engines
+filter out precompiled platform gems at activation and always resolve
+the `ruby` variant, which does not vendor the native library:
+
+1. Install `libleptris` on the host — build from source (above) or set
+   `LEPTRIS_LIB_PATH=/path/to/libleptris.{so,dylib}`.
+2. `gem install leptris` (or `bundle install`) — activation succeeds
+   like on MRI, and FFI loads the system library at require time.
+
+The startup `LoadError` names this remedy when the library is missing.
+
 == Parsing
 
 The top-level entry point is `Leptris::XML`. Parse a string or an IO:

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/TODO.restructure/21-typeddata-variant-prototype.md

@@ -8,6 +8,10 @@ in verification order:
 - [x] Minimal C ext (one file): a TypedData class holding
       (pointer, document-ref) — prototype built and measured
       (ext + bench preserved under /tmp/typedproto, /tmp/bench_typed.rb).
+- [x] NOTE (2026-09-12): /tmp was wiped — the prototype ext and
+      bench under /tmp/typedproto, /tmp/bench_typed.rb are GONE.
+      The measurements below stand (recorded here); the build
+      phase rebuilds the ext properly under ext/ anyway.
 - [x] Measured (100k holders, GC.settled RSS deltas):
       FFI::Pointer-backed 154 B/node vs TypedData 40 B/node —
       **114 B/node saved**, ~40% of the wrapper layer (#147's

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.121.0"
+  VERSION = "1.9.144.1"
 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/document.rb

@@ -119,18 +119,38 @@ class Leptris::XML::Document
     wrap(raw)
   end
 
-  # Deep copy of +element+ as the root of a NEW document — the one
-  # authority behind Node#dup / Element#dup and the indent-unit
-  # path (the C copy keeps every child kind and namespace since
-  # libleptris 1.9.76 — #696/#721/#812). The returned tree is
-  # detached from the original and fully navigable.
-  def self.copy_of(element)
+  # Deep copy of +node+ in a NEW document — the one authority
+  # behind Node#dup / Element#dup and the indent-unit path.
+  # Elements deep-copy through the C copier (every child kind and
+  # namespace survives, #696/#721/#812); every other node kind
+  # rebuilds by value through this document's factories — their
+  # entire state is the payload the factory takes (#161). The
+  # returned node is detached from the original and fully usable.
+  def self.copy_of(node)
     new_doc = create
-    copy = Leptris::XML::FFI.leptris_element_copy(element.c_ptr, new_doc.c_ptr)
+    return rebuild_node(node, new_doc) unless node.element?
+    copy = Leptris::XML::FFI.leptris_element_copy(node.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
 
+  def self.rebuild_node(node, new_doc)
+    case node.type
+    when Leptris::XML::FFI::NODE_TEXT
+      new_doc.create_text_node(node.content)
+    when Leptris::XML::FFI::NODE_CDATA
+      new_doc.create_cdata(node.content)
+    when Leptris::XML::FFI::NODE_COMMENT
+      new_doc.create_comment(node.content)
+    when Leptris::XML::FFI::NODE_PI
+      new_doc.create_processing_instruction(node.name, node.content)
+    else
+      raise Leptris::XML::Error,
+        "dup is not supported for #{node.class} nodes"
+    end
+  end
+  private_class_method :rebuild_node
+
   # Convert a raw LeptrisDocument pointer into a Ruby Document with safe
   # GC lifetime management. The finalizer captures the raw address
   # integer (not the Document or Pointer object — those would prevent

data/lib/leptris/xml/element.rb

@@ -79,7 +79,13 @@ class Leptris::XML::Element < Leptris::XML::Node
       return v
     end
     ensure_alive!
-    Leptris::XML::FFI.leptris_element_attribute(@c_ptr, name)
+    v = Leptris::XML::FFI.leptris_element_attribute(@c_ptr, name)
+    # Namespace-aware misses (an undeclared prefix never resolves
+    # through in-scope declarations) fall back to the WRITTEN name
+    # — the same flat face #attributes exposes, so a value written
+    # as el["n:x"] reads back through el["n:x"] (#161).
+    return v unless v.nil?
+    attributes[name]&.value
   end
   alias_method :attr, :[]
   alias_method :get_attribute, :[]
@@ -94,7 +100,11 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def key?(name)
     ensure_alive!
-    Leptris::XML::FFI.leptris_element_has_attribute(@c_ptr, name.to_s) != 0
+    return true if Leptris::XML::FFI.leptris_element_has_attribute(
+      @c_ptr, name.to_s) != 0
+    # Same written-name fallback as #[] — the engine lookup is
+    # namespace-aware and misses undeclared prefixes (#161).
+    attributes.key?(name.to_s)
   end
   alias_method :has_attribute?, :key?
 
@@ -196,6 +206,15 @@ class Leptris::XML::Element < Leptris::XML::Node
     Leptris::XML::FFI.leptris_element_prefix(@c_ptr)
   end
 
+  # The written qualified name — "foo:child" with a prefix, the
+  # bare local name without. The explicit contract behind the
+  # #name/#prefix split: #name answers the local part, the
+  # serialized form uses this spelling (#161).
+  def qualified_name
+    p = prefix
+    p ? "#{p}:#{name}" : name
+  end
+
   def prepend_child(node)
     ensure_writable!
     Leptris::XML::FFI.check_status(
@@ -341,6 +360,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
@@ -843,6 +909,10 @@ attach_function :leptris_parse_string,
       XPATH_BOOLEAN = 1
       XPATH_NUMBER = 2
       XPATH_STRING = 3
+      # XPath 3.0 function item (libleptris TODO 07 lane): a closure
+      # or named function reference. Not callable across the FFI
+      # boundary yet — wrap_xpath_result raises explicitly.
+      XPATH_FUNCTION = 4
 
       XPATH_NODE_ELEMENT = 0
       XPATH_NODE_ATTRIBUTE = 1

data/lib/leptris/xml/node.rb

@@ -430,11 +430,10 @@ class Leptris::XML::Node
 
   # Deep copy in a NEW document via Document.copy_of (the single
   # copy seam — comment/PI children and namespaces both survive,
-  # #696/#721/#812; the copier is pool-threaded, ~2.3x Nokogiri).
+  # #696/#721/#812; the copier is pool-threaded, ~2.3x Nokogiri;
+  # non-element kinds rebuild by value — #161).
   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.copy_of(self)
   end
   alias_method :clone, :dup

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
@@ -163,6 +199,12 @@ module Leptris::XML::Searchable
       v = Leptris::XML::FFI.read_owned_string(str_ptr)
       Leptris::XML::FFI.leptris_xpath_result_free(result_ptr)
       v
+    when Leptris::XML::FFI::XPATH_FUNCTION
+      Leptris::XML::FFI.leptris_xpath_result_free(result_ptr)
+      raise Leptris::XML::XPathError,
+            'XPath function items cannot cross the FFI boundary yet ' \
+            '(libleptris TODO 07; call them inside the expression, ' \
+            'e.g. for-each((1,2), function($n){$n+1}))'
     else
       Leptris::XML::FFI.leptris_xpath_result_free(result_ptr)
       raise Leptris::XML::XPathError, "unknown xpath result type #{type}"

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.1
 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