leptris 1.9.144.1 → 1.9.156.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '01429a81e019ba9e4ecf9d2a7c23ada3b4d2c6dc3849c5a0be469bbab52b5c92'
-  data.tar.gz: 21bc4d37174f592fe72821f9fd7074eb7521c7ff4eacad42141720f2e235c97b
+  metadata.gz: c649879fc6a03c38e8c36df987c079271d62583992ae6836f23f53dae102a82e
+  data.tar.gz: 91c1a0d1f5101f73841bfee5ca6fd4ad07bbe36a9b6035c7542d3c43bac14b7e
 SHA512:
-  metadata.gz: 181136f9e8da6a067bba876bbbfe5e841c062470fce5c6a521de413f5abd4a33d824eb387155021b486ff5063e70d96077156b79656440ee418d4b388bc5297c
-  data.tar.gz: 3e088d8220ec7c3c40f4e9869caf8cc73e08606ac4f7035a9f8a277454fafc1d7921c11fe17aa64f4c328254362103962bf05218385e1855c27fad3663b5b915
+  metadata.gz: 12b2aaa87ab88a85f9c2023a976869a30ae53bb6671d8bf47d0097e87870a5b8eb3fe0b728d564ae6312b46f2343b2a3db5720cdd6b4ce27a86c1ddb9826547e
+  data.tar.gz: 5435202bd16c7175dfb1a36d49bf3027ed562729f7f99a1a98b393aa9daf85f0a338e019f953864ad07ee13be3457f15b2e7b6e730e67db9d8adf2c4b2f76703

data/CHANGELOG.md

@@ -5,6 +5,121 @@ 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.156.2] - 2026-09-13
+
+### Added
+
+- **#183: XPath version selection** (mirroring leptris-py#105):
+  `xpath`/`at_xpath` take a trailing `version:` selector —
+  `doc.xpath("count(//b)", version: "1.0")` evaluates through the
+  strict 1.0 engine lane (3.x syntax raises), `"3.1"` the full
+  grammar; `XPath.compile(expr, version:)` pins compiled
+  expressions the same way. Carried positionally — a declared
+  keyword is impossible without breaking the namespace-binding
+  hash channel (Ruby converts a trailing String-keyed hash into
+  keywords the moment one exists), so a `:version` key whose
+  VALUE is a version selector ("1.0"/"3.1"/:xpath10/:xpath31)
+  selects the channel; dotted-number values raise at the boundary
+  with the valid values; any other value stays a prefix binding
+  (a prefix literally named "version" keeps working). `version:`
+  combined with namespace bindings raises (the versioned engine
+  entry takes no ns set yet), as does `version:` on css. The nil
+  default keeps the existing eval path verbatim.
+\n## [1.9.156.1] - 2026-09-13
+
+### Added
+
+- **`Element#create_child(name)`** — the fused create+append
+  (libleptris 1.9.153 `leptris_element_create_child`, audit 290)
+  landed on main seconds after the 1.9.156.0 platform gems were
+  built and published, so that release ships without the binding
+  face. This patch release carries it: one C call, tree semantics
+  identical to `create_element` + `add_child`, the builder-shape
+  single call.
+
+## [1.9.156.0] - 2026-09-13
+
+### Security/correctness
+
+- **Lockstep with libleptris 1.9.156 (1.9.152 → 1.9.156)** — carries
+  the **#1038 heap-corruption fix** (engine regression window:
+  libleptris 1.9.151–1.9.155; root-doc map entries outlived their
+  document and wrote through freed pools — roaming crashes in
+  downstream binding suites at ~5% of runs). The two gem versions
+  that embedded the affected engine, **1.9.152.0 and 1.9.152.1,
+  are YANKED**; upgrade to 1.9.156.0.
+
+### Added
+
+- **`Element#create_child(name)`** (libleptris 1.9.153): the fused
+  create+append — one document resolution, one C call, tree
+  semantics identical to `create_element` + `add_child`; the
+  builder-shape single call.
+
+### Changed
+
+- Engine: WHATWG template-mode gaps closed (1.9.154/1.9.155):
+  frame/frameset drops inside templates, in-column-group token
+  gating, `</template>` inside `<select>`, foreign-content
+  template end-tag matching — html5lib corpus 1197 → 1206;
+  Nokogiri parity floor held. Audit 289 → 290
+  (leptris_element_create_child).
+
+## [1.9.152.1] - 2026-09-13
+
+### Fixed
+
+- **#178 (ask 1): attach seams lift in-scope namespace
+  declarations on adoption.** The engine's attach entries move a
+  subtree but not the source's in-scope declarations — a
+  cross-document (or out-of-scope) `add_child` /
+  `prepend_child` / `add_next_sibling` / `add_previous_sibling` /
+  `Document#root=` produced serialized output with UNDECLARED
+  prefixes. `Element.lift_namespaces_for_adoption` snapshots the
+  node's scope before the move and re-declares on the moved
+  element everything the target does not already resolve
+  identically (own declarations and identical target scopes add
+  nothing — same-scope moves stay output-identical).
+
+### Added
+
+- **#178 (ask 3): `benchmark/consumer_pipeline.rb`** — the
+  model-pipeline leg: a nested 7000-item document walked into
+  typed objects, with `GC.stat` allocation deltas (load
+  independent: ~799k allocations per run) and fresh-process
+  one-shot medians (n=9, the CLI-workload shape where YJIT never
+  amortizes).
+
+## [1.9.156.0] - 2026-09-13
+
+### Changed
+
+- **Lockstep with libleptris 1.9.156** (1.9.152 → 1.9.156; audit
+  290/290 — new symbol `leptris_element_create_child` attached):
+  pulls in the leptris/leptris#1038 heap-corruption fix — stale
+  root-doc map entries (pool-fallback creates + XInclude
+  adopted-child free) resolved freed documents after address
+  recycling, corrupting the heap in ~5-10% of long-running
+  processes; entries now die with their document. 1.9.152 and
+  1.9.152.1 shipped inside the affected range (1.9.151-154).
+  Also rides: WHATWG `<template>` cgroup drops and `</template>`
+  pop-through (html5lib corpus 1200 → 1206), frame/frameset
+  in-template drops (1.9.154), and the lane-18 DOM perf rows.
+
+## [1.9.152.0] - 2026-09-13
+
+### Changed
+
+- **Lockstep with libleptris 1.9.152** (1.9.144 → 1.9.152; no new
+  C surface — audit 289/289): the lane-18 DOM mutation performance
+  arc rides the binding directly — attr-heavy parse up to 2.7x
+  faster (1.9.147/1.9.149), the DOM create path 91.6 → 6.6 ns/op
+  and the append row 401 → ~258 µs (1.9.150–1.9.152), set-attr row
+  390 → 262 µs. WHATWG HTML: `<template>` insertion modes
+  (1.9.146/1.9.148) — an open template is a scope boundary for
+  table-context starts, and each open template tracks its saved
+  insertion mode (implied tr/tbody/rows per WHATWG 13.2.6.4.10).
+
 ## [1.9.144.1] - 2026-09-12
 
 ### Fixed

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.144"
+LIBLEPTRIS_VERSION = "1.9.156"
 # 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.144.1"
+  VERSION = "1.9.156.2"
 end

data/lib/leptris/xml/document.rb

@@ -244,6 +244,9 @@ class Leptris::XML::Document
   # document's pool until #free).
   def root=(element)
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
+    # A document root has no in-scope declarations of its own —
+    # lift everything the element's source scope carried (#178).
+    Leptris::XML::Element.lift_namespaces_for_adoption(element, {})
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_document_set_root(@c_ptr, element.c_ptr))
     @version += 1

data/lib/leptris/xml/element.rb

@@ -215,8 +215,35 @@ class Leptris::XML::Element < Leptris::XML::Node
     p ? "#{p}:#{name}" : name
   end
 
+  # Cross-document and cross-scope adoption (#178 ask 1): the
+  # engine's attach entries move a subtree but do not lift the
+  # source's in-scope namespace declarations, so serialized output
+  # can carry undeclared prefixes. Re-declares on +node+ everything
+  # from its in-scope set that +target_scope+ (the attach target's
+  # in-scope map) does not already resolve identically — the
+  # declarations ride the moved element, staying local to the
+  # adopted subtree. Call BEFORE attaching: the source scope is
+  # read through the node's current ancestors. Identical scopes
+  # (the common same-document move) add nothing.
+  def self.lift_namespaces_for_adoption(node, target_scope)
+    return unless node.is_a?(Leptris::XML::Element)
+    # Declarations the node already carries (its own definitions —
+    # preserved by the C copy and by moves) ride it as-is; lifting
+    # must not duplicate them, only what came from ANCESTORS.
+    own = node.namespace_definitions.each_with_object({}) do |ns, h|
+      h[ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns"] = ns.href
+    end
+    node.namespaces.each do |key, uri|
+      next if target_scope[key] == uri || own[key] == uri
+      prefix = key.start_with?("xmlns:") ? key.delete_prefix("xmlns:") : nil
+      node.add_namespace_definition(prefix, uri)
+    end
+    nil
+  end
+
   def prepend_child(node)
     ensure_writable!
+    Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_prepend_child(@c_ptr, node.c_ptr))
     node
@@ -224,6 +251,7 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def add_next_sibling(node)
     ensure_writable!
+    Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_insert_after(@c_ptr, node.c_ptr))
     node
@@ -231,6 +259,7 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def add_previous_sibling(node)
     ensure_writable!
+    Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_insert_before(@c_ptr, node.c_ptr))
     node
@@ -302,10 +331,24 @@ class Leptris::XML::Element < Leptris::XML::Node
   end
   alias_method :clone, :dup
 
+  # Fused create+append (libleptris 1.9.153): builds a child
+  # element of +name+ in this element's document and attaches it
+  # in ONE C call — the builder-shape single call
+  # (leptris_element_create_child). Tree semantics identical to
+  # document.create_element(name) + add_child.
+  def create_child(name)
+    ensure_writable!
+    ptr = Leptris::XML::FFI.leptris_element_create_child(@c_ptr, name.to_s)
+    raise Leptris::XML::Error,
+      "leptris_element_create_child failed for #{name.inspect}" if ptr.null?
+    Leptris::XML::Node.wrap_fresh(ptr, @document, Leptris::XML::FFI::NODE_ELEMENT)
+  end
+
   def add_child(node_or_markup)
     ensure_writable!
     case node_or_markup
     when Leptris::XML::Node
+      Leptris::XML::Element.lift_namespaces_for_adoption(node_or_markup, namespaces)
       Leptris::XML::FFI.check_status(
         Leptris::XML::FFI.leptris_element_append_child(@c_ptr, node_or_markup.c_ptr))
       node_or_markup

data/lib/leptris/xml/ffi.rb

@@ -435,6 +435,8 @@ attach_function :leptris_parse_string,
 
       attach_function :leptris_element_create,
         [:leptris_document, :string], :leptris_element
+      attach_function :leptris_element_create_child,
+        [:leptris_element, :string], :leptris_element
       attach_function :leptris_element_set_name,
         [:leptris_element, :string], :leptris_status
       attach_function :leptris_element_set_text,
@@ -455,6 +457,10 @@ attach_function :leptris_parse_string,
         [:leptris_element, :string], :leptris_status
       attach_function :leptris_element_append_child,
         [:leptris_element, :leptris_element], :leptris_status
+      # Fused create+append (libleptris 1.9.153): one document
+      # resolution, identical tree semantics to the two-call pair.
+      attach_function :leptris_element_create_child,
+        [:leptris_element, :string], :leptris_element
       attach_function :leptris_element_prepend_child,
         [:leptris_element, :leptris_element], :leptris_status
       attach_function :leptris_element_insert_before,

data/lib/leptris/xml/searchable.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
 module Leptris::XML::Searchable
+  # Values that make a :version key the version channel (#183,
+  # mirroring leptris-py#105); anything else is a namespace prefix.
+  VERSION_SELECTORS = ["1.0", "3.1", :xpath10, :xpath31].freeze
+
   def xpath(*paths)
-    handler, ns, _vars = parse_search_args(paths)
+    handler, ns, version = parse_search_args(paths)
     raise ArgumentError, "custom XPath handlers not supported" if handler
     expr = paths.join(" | ")
 
@@ -10,7 +14,16 @@ module Leptris::XML::Searchable
     context_ptr = is_a?(Leptris::XML::Document) ? nil : c_ptr
 
     result_ptr =
-      if ns && !ns.empty?
+      if version
+        if ns && !ns.empty?
+          raise ArgumentError,
+            "version: cannot be combined with namespace bindings " \
+            "(the versioned engine entry takes no ns set yet)"
+        end
+        Leptris::XML::FFI.leptris_xpath_eval_versioned(
+          doc_ptr, context_ptr, expr,
+          Leptris::XML::Searchable.xpath_version_code(version), nil)
+      elsif ns && !ns.empty?
         xpath_eval_with_namespaces(doc_ptr, context_ptr, expr, ns)
       else
         Leptris::XML::FFI.leptris_xpath_eval(doc_ptr, context_ptr, expr)
@@ -24,7 +37,7 @@ module Leptris::XML::Searchable
   end
 
   def at_xpath(*paths)
-    handler, ns, _vars = parse_search_args(paths)
+    handler, ns, version = parse_search_args(paths)
     raise ArgumentError, "custom XPath handlers not supported" if handler
     expr = paths.join(" | ")
 
@@ -32,7 +45,16 @@ module Leptris::XML::Searchable
     context_ptr = is_a?(Leptris::XML::Document) ? nil : c_ptr
 
     result_ptr =
-      if ns && !ns.empty?
+      if version
+        if ns && !ns.empty?
+          raise ArgumentError,
+            "version: cannot be combined with namespace bindings " \
+            "(the versioned engine entry takes no ns set yet)"
+        end
+        Leptris::XML::FFI.leptris_xpath_eval_versioned(
+          doc_ptr, context_ptr, expr,
+          Leptris::XML::Searchable.xpath_version_code(version), nil)
+      elsif ns && !ns.empty?
         xpath_eval_with_namespaces(doc_ptr, context_ptr, expr, ns)
       else
         Leptris::XML::FFI.leptris_xpath_eval(doc_ptr, context_ptr, expr)
@@ -64,8 +86,9 @@ module Leptris::XML::Searchable
   alias_method :%, :at
 
   def css(*args)
-    handler, ns, _ = parse_search_args(args)
+    handler, ns, version = parse_search_args(args)
     raise ArgumentError, "namespace bindings not supported in css" if ns && !ns.empty?
+    raise ArgumentError, "version: is XPath-only" if version
     raise ArgumentError, "custom CSS handlers not supported" if handler
     # Nokogiri semantics: css is receiver-relative — absolute "//"
     # from a Document, descendant ".//" from elements and fragments.
@@ -76,8 +99,9 @@ module Leptris::XML::Searchable
   end
 
   def at_css(*args)
-    handler, ns, _ = parse_search_args(args)
+    handler, ns, version = parse_search_args(args)
     raise ArgumentError, "namespace bindings not supported in css" if ns && !ns.empty?
+    raise ArgumentError, "version: is XPath-only" if version
     raise ArgumentError, "custom CSS handlers not supported" if handler
     prefix = is_a?(Leptris::XML::Document) ? "//" : ".//"
     expr = args.map { |r| Leptris::XML::CssToXPath.convert(r, prefix: prefix) }
@@ -131,6 +155,15 @@ module Leptris::XML::Searchable
     end
   end
 
+  # Trailing-argument contract (#183): a String-keyed hash is the
+  # namespace-binding channel — as is a Symbol-keyed hash (the
+  # legacy prefix vocabulary, {x: "urn:x"}); a :version key whose
+  # VALUE is a version selector is the version-selection channel
+  # (xpath("//b", version: "1.0"), mirroring leptris-py#105). A
+  # DECLARED keyword cannot carry this: the moment #xpath declares
+  # one, Ruby converts the trailing namespace hash into keywords
+  # (unknown keyword: "p") — so both channels stay positional and
+  # dispatch on key/value here.
   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
@@ -143,7 +176,27 @@ module Leptris::XML::Searchable
     unless vars.nil? || vars.empty?
       raise ArgumentError, "XPath variable bindings are not supported"
     end
-    [handler, ns, vars]
+    # Value-based disambiguation is load-bearing: Symbol keys are
+    # also the namespace vocabulary, and bare keywords FUSE into a
+    # preceding String-keyed hash at the call site ({"p" => uri,
+    # version: "1.0"} arrives as ONE hash). A :version key with any
+    # other value stays a prefix binding.
+    version = nil
+    if ns.is_a?(Hash)
+      v = ns[:version]
+      if VERSION_SELECTORS.include?(v)
+        version = ns.delete(:version)
+        ns = nil if ns.empty?
+      elsif v.is_a?(String) && v.match?(/\A\d+\.\d+\z/)
+        # A dotted-number :version value is version INTENT — raise
+        # with the valid values rather than silently binding a
+        # prefix literally. Genuine prefix bindings carry URIs.
+        raise ArgumentError,
+          "unknown XPath version #{v.inspect} " \
+          "(valid: \"1.0\"/:xpath10, \"3.1\"/:xpath31)"
+      end
+    end
+    [handler, ns, version]
   end
 
   def looks_like_xpath?(str)

data/lib/leptris/xml/xpath.rb

@@ -18,28 +18,44 @@ class Leptris::XML::XPath
 
   attr_reader :expression
 
-  def self.compile(expression)
+  # +version+ (#183, mirroring leptris-py#105): nil compiles the
+  # full-grammar expression (the default); :xpath10 / "1.0" pins
+  # the strict XPath 1.0 surface. Validated at the boundary.
+  def self.compile(expression, version: nil)
     raw = Leptris::XML::FFI.leptris_xpath_compile(expression.to_s)
     if raw.null?
       raise Leptris::XML::XPathError,
         "invalid expression: #{Leptris::XML::FFI.leptris_last_error}"
     end
-    new(expression.to_s, CompiledHandle.new(raw))
+    version_code =
+      Leptris::XML::Searchable.xpath_version_code(version) if version
+    new(expression.to_s, CompiledHandle.new(raw), version_code)
   end
 
-  def initialize(expression, handle)
+  def initialize(expression, handle, version_code = nil)
     @expression = expression
     @handle = handle
+    @version_code = version_code
   end
 
   # Evaluates against +doc_or_element+. An optional trailing hash of
   # namespace bindings ("prefix" => uri) routes the evaluation through
   # the namespace-bound path, matching Searchable#xpath semantics.
+  # A compiled version pin routes through the engine's versioned
+  # entry instead of the compiled handle — there is no compiled
+  # versioned lane yet (engine gap), so the strict-1.0 surface is
+  # enforced per evaluation over the stored expression.
   def eval(doc_or_element, ns = nil)
     context = Leptris::XML::EvaluationContext.of(doc_or_element)
     document = context.document
     result_ptr =
-      if ns && !ns.empty?
+      if @version_code
+        raise ArgumentError,
+          "version: cannot be combined with namespace bindings "           "(the versioned engine entry takes no ns set yet)" if ns && !ns.empty?
+        Leptris::XML::FFI.leptris_xpath_eval_versioned(
+          document.c_ptr, context.context_node_ptr,
+          @expression, @version_code, nil)
+      elsif ns && !ns.empty?
         Leptris::XML::FFI.with_ns_set(ns) do |set|
           Leptris::XML::FFI.leptris_xpath_compiled_eval_ns(
             @handle, document.c_ptr, context.context_node_ptr, set)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.144.1
+  version: 1.9.156.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-12 00:00:00.000000000 Z
+date: 2026-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi