leptris 1.9.216.0-arm-linux → 1.9.221.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a2622f48a888b3a14f647caa24a19bc9a622dd843f62b55300523c7a658b7e7
-  data.tar.gz: '059f9bc0fe353103f5f9a12e540dfd3a17f9a700db9201253525d265a413e9db'
+  metadata.gz: acdcd23826e0678ede2a367350b1871a3ccc00d8cd77b5d6faabaf05c6f7039c
+  data.tar.gz: f3763c24dcc489a498e74e71746430029394e699f1be50c94e7e191719bdff0a
 SHA512:
-  metadata.gz: 92137716049c65c944745eb9772e1731984bbb20c0a4bfb7e4e04cc5bd5fd33c9208c79392a02c6713bfdbaf71498beb63b780b5365cb4b665d37c353291abf8
-  data.tar.gz: f1360b1b0ef61c5c2380bd8a8aee10f5fc90d0e3b2416ffde0091a6e83fa986ebf8dd244d9331e02ccd96c5475674c4b3ddaac81d41b5ea50880493c411493ee
+  metadata.gz: 4e582cff85f5f651b3edea67acb0ad59d83f38a1b767c8b3c86b06a9006224db00cb9a3cb438947c01d5625877e5b871bb2835e55776a45bd530d79dd4bf7f50
+  data.tar.gz: 6563e1b22669bb462c433183246c7ce6551ec76e244459463445d2c1b97d9bb24b47b338c18ae107b7c8f8009e09613e18306759967d8a004a9c4fb345e3ff80

data/CHANGELOG.md

@@ -5,6 +5,25 @@ 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.221.0] - 2026-09-22
+
+### Performance — engine sync (1.9.221)
+
+- Vendored libleptris 1.9.221: per-document overflow teardown in
+  the dispatch row (#682). No binding-facing surface changes;
+  audit 342/342, suite 770/0.
+
+## [1.9.220.0] - 2026-09-22
+
+### Performance — engine sync (1.9.217–1.9.220)
+
+- Vendored libleptris 1.9.220: four perf releases — the HTML
+  parse tag-id classifier stack + in-place borrowed text runs
+  (#1218 slices 1-2), the authoritative content_len text-join
+  pass (#1285 slice 1), and borrowed string-values for
+  `value-of select="."` (#682). No binding-facing surface
+  changes; audit 342/342, suite 770/0.
+
 ## [1.9.216.0] - 2026-09-21
 
 ### Added — the plan-ABI consumer contract (#298 fully bound; engine 1.9.214–216)

data/README.adoc

@@ -504,10 +504,69 @@ Row kinds: `:scalar`, `:collection`, `:nested` (via `plan:`), `:raw`
 offset + `type_tag` echo, matching `Node#byte_offset`). Namespace
 binding lives on plans: `ns:` is `:none` (default), `:any`, or
 `{ exact: "urn:..." }`; `flags:` also accepts `:cdata`, `:ordered`,
-`:ns_lenient` (#754 out-of-namespace adoption). Children the plan
-does not describe are skipped; undescribed document order within a
-row is preserved. `#walk` returns a lazy `PlanValue` tree (the
-result outlives the document); `#to_ruby` materializes it.
+`:ns_lenient` (#754 out-of-namespace adoption), and `:order_spine`
+(#1273 — unmatched sibling text/comment/PI runs emit as positioned
+scalars so ordered hosts rebuild element order without re-parsing).
+Children the plan does not describe are skipped; undescribed document
+order within a row is preserved. `#walk` returns a lazy `PlanValue`
+tree (the result outlives the document); `#to_ruby` materializes it.
+
+=== Typed scalars and the fused entry (#230/#298)
+
+Plan rows accept `type: :integer | :float | :boolean` — the walk
+parses the values natively (in-pass, libleptris #1269a) and
+`#to_ruby` / the bulk face return `Integer` / `Float` / `true` /
+`false`. Unparseable values fall back to the raw String;
+`PlanValue#string_value` stays the raw escape, and
+`#int_value` / `#float_value` / `#bool_value` expose the parsed
+accessors directly.
+
+`Descriptor#materialize(source)` is the fused entry: source bytes →
+typed rows in ONE C call — parse, walk, and free happen natively
+(#1269b); the standalone `PlanValue` tree is all that surfaces.
+
+[source,ruby]
+----
+descriptor = Leptris::XML::Descriptor.build(
+  name: "iso",
+  children: [{ name: "row", kind: :collection, plan: {
+    name: "row",
+    attributes: [{ name: "id", kind: :scalar, type: :integer }],
+    children: [
+      { name: "price", kind: :scalar, type: :float },
+      { name: "active", kind: :scalar, type: :boolean },
+    ] } },
+  ])
+
+rows = descriptor.materialize(xml_source)   # one C call
+rows.as_kwarg_hash[:children]["row"]        # typed, hydrator-ready
+----
+
+=== Predicate rows (#1272) and order identity (#1273)
+
+Same-wire-name rows can partition on attribute values with `when:` —
+AND across pairs, exclusive routing (first matching row wins per
+occurrence):
+
+[source,ruby]
+----
+Leptris::XML::Descriptor.build(
+  name: "r",
+  children: [
+    { name: "item", kind: :collection, when: { "kind" => "a" },
+      plan: { name: "item", children: [{ name: "name", kind: :scalar }] } },
+    { name: "item", kind: :collection, when: { "kind" => "b" },
+      plan: { name: "item", children: [{ name: "name", kind: :scalar }] } },
+  ])
+----
+
+`PlanValue#node_kind` and `#order_index` carry document-order
+identity for matched rows (and, under `:order_spine`, for the
+interleaved text runs) — ordered/mixed content reconstructs
+without fragment re-parsing. `PlanValue#as_kwarg_hash` is the
+bulk hydrator face: one Ruby call per node returns the typed
+attribute/children hash (the crossings floor on the 5k-row ISO
+fixture is ~4 FFI crossings per row, pinned by spec).
 
 == XQuery
 

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.216"
+LIBLEPTRIS_VERSION = "1.9.221"
 # 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.216.0"
+  VERSION = "1.9.221.0"
 end

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.216
+- libleptris v1.9.221
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,73 @@
 ## [Unreleased]
 
+## [1.9.221] - 2026-09-22
+
+### Performance
+
+- per-document overflow teardown (#682 dispatch row) (dom)
+
+
+
+## [1.9.220] - 2026-09-21
+
+### Performance
+
+- in-place borrowed text runs (#1218 slice 2) (html)
+
+
+
+## [1.9.219] - 2026-09-21
+
+### Performance
+
+- authoritative content_len in the text-join passes (#1285 slice 1) (dom)
+
+
+
+## [1.9.218] - 2026-09-21
+
+### Performance
+
+- borrowed string-value for value-of select='.' (#682) (xslt)
+
+
+
+## [1.9.217] - 2026-09-21
+
+### Performance
+
+- tag-id classifier stack + single-lookup start tags (#1218) (html)
+
+
+
+## [1.9.217] - 2026-09-21
+
+### Added — plan-ABI additive v1 (descriptor materialization, PR #1275)
+
+Closes #1272, #1273, #1269 — the binding-facing plan upgrades:
+
+- **#1272 attribute-predicate rows**: child rows and attribute plans
+  accept `leptris_attr_predicate` pairs; same-wire siblings partition
+  by predicate (AND across pairs, exclusive routing only when
+  predicates are present — the #1115 multi-namespace behavior is
+  untouched).
+- **#1273 document-order identity**: every result value carries an
+  `order_index` cumulative across rows (strictly increasing in
+  document order); `LEPTRIS_PLAN_FLAG_EMIT_ORDER_SPINE` optionally
+  appends unmatched text runs so interleavings reconstruct without
+  fragment re-parses.
+- **#1269 in-pass types + fusion**: rows carry a `type_tag`
+  (1=int / 2=float / 3=bool) executed during the walk with soft-fail
+  to string; `leptris_plan_materialize` fuses parse→walk→free into
+  one call for the binding hot path.
+- New accessors: `leptris_plan_value_node_kind/_order_index/_int/
+  _float/_bool`. `LEPTRIS_PLAN_ABI_VERSION` stays 1 — all additions
+  are trailing fields, aggregate initializers keep compiling.
+
+Five new specs in `test/abi/test_descriptor.cpp` (Plan1272/1273/
+1269a/1269b); full ctest green across all 24 CI legs.
+
+
 ## [1.9.216] - 2026-09-21
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.216
+    VERSION 1.9.221
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/TODO.max-perf/7-validate-bindings.md

@@ -1,6 +1,16 @@
 # Lever 7: Lane 16.6 — leptris validate CLI + bindings
 
-Status: TODO. `leptris validate` subcommand (XML well-formedness
-+ DTD + RNG paths through the public API) and the binding-side
-validate wrappers. Small, closed scope; CLI command registration
-follows cli/CLI_ARCHITECTURE.md (new file in cli/commands/).
+Status: DONE (issue #1183). All three legs shipped and verified on
+main:
+
+- **CLI**: `cli/commands/validate.c` (286 lines) — RELAX NG +
+  Schematron validation, stdin/file input; registered in
+  `cli/main.c:97`, listed in the help text (`leptris validate`).
+- **leptris-ruby**: `RelaxNG#validate/#valid?/#validate_errors/
+  #validate_report`, `Schematron#validate/#valid?`,
+  `DTD#validate/#valid?` (lib/leptris/xml/{relaxng,schematron,dtd}.rb).
+- **leptris-py**: `RelaxNG`, `DTD`, `Schematron` exported from the
+  package root (leptris/__init__.py).
+
+Well-formedness validation is `leptris_parse_string` itself (line:col
+error contract); no separate wrapper required.

data/vendor-src/libleptris/benchmarks/html/bench_html_parse.c

@@ -67,7 +67,28 @@ static size_t gen_entities(char* out, int paras) {
     return len;
 }
 
+/* Table-of-rows shape (#1218): well-formed medium HTML — one big
+ * tbody, no error-recovery cases, matching the serialbench
+ * medium.html fixture class the issue reports 3.4-7x on. */
+static size_t gen_table_rows(char* out, int rows) {
+    size_t len = 0;
+    len += (size_t)sprintf(out + len,
+        "<!DOCTYPE html><html lang='en'><head><meta charset='utf-8'>"
+        "<title>Report</title></head><body>"
+        "<table class='data'><thead><tr><th>Id</th><th>Name</th>"
+        "<th>Value</th></tr></thead><tbody>");
+    for (int r = 0; r < rows; r++)
+        len += (size_t)sprintf(out + len,
+            "<tr class='r%d'><td>%d</td><td>row-%d</td>"
+            "<td data-v='%d'>%d.%02d</td></tr>",
+            r & 1, r, r, r, r, r & 99);
+    len += (size_t)sprintf(out + len,
+        "</tbody></table></body></html>");
+    return len;
+}
+
 int main(void) {
+    const char* only = getenv("HTML_BENCH_ONLY"); /* page|entities|table */
     size_t cap = 1u << 22;
     char* html = (char*)malloc(cap);
     if (!html) return 1;
@@ -80,6 +101,7 @@ int main(void) {
 
     int reps = getenv("HTML_BENCH_REPS") ? atoi(getenv("HTML_BENCH_REPS")) : 9;
     double best = 1e18;
+    if (!only || strcmp(only, "page") == 0) {
     for (int i = 0; i < reps; i++) {
         double t0 = benchmark_time_us();
         LeptrisDocument d = leptris_parse_html_string(html, len, &st);
@@ -89,8 +111,10 @@ int main(void) {
     }
     printf("leptris html parse: %zu bytes, %.0f us, %.1f MB/s (best of %d)\n",
            len, best, (double)len / best, reps);
+    }
 
     /* Entity-laden second shape (nokogiri reference: same page). */
+    if (!only || strcmp(only, "entities") == 0) {
     len = gen_entities(html, 20000);
     warm = leptris_parse_html_string(html, len, &st);
     if (!warm) { printf("entity parse failed\n"); return 1; }
@@ -106,6 +130,26 @@ int main(void) {
     printf("leptris html parse (entity-laden): %zu bytes, %.0f us, "
            "%.1f MB/s (best of %d)\n",
            len, best, (double)len / best, reps);
+    }
+
+    /* Table-of-rows ~2MB shape (#1218, serialbench medium class). */
+    if (!only || strcmp(only, "table") == 0) {
+    len = gen_table_rows(html, 32000);
+    warm = leptris_parse_html_string(html, len, &st);
+    if (!warm) { printf("table parse failed\n"); return 1; }
+    leptris_document_free(warm);
+    best = 1e18;
+    for (int i = 0; i < reps; i++) {
+        double t0 = benchmark_time_us();
+        LeptrisDocument d = leptris_parse_html_string(html, len, &st);
+        double us = benchmark_time_us() - t0;
+        leptris_document_free(d);
+        if (us < best) best = us;
+    }
+    printf("leptris html parse (table-rows): %zu bytes, %.0f us, "
+           "%.1f MB/s (best of %d)\n",
+           len, best, (double)len / best, reps);
+    }
     free(html);
     return 0;
 }

data/vendor-src/libleptris/src/leptris/dom/compact.c

@@ -9,6 +9,7 @@
  */
 
 #include "compact.h"
+#include "../leptris_internal.h"   /* struct leptris_document (overflow_entries) */
 #include "../common/port.h"
 #include <stdlib.h>
 #include <string.h>
@@ -158,6 +159,14 @@ int leptris_compact_overflow_set(LeptrisCompactOverflowTable* table,
     table->buckets[index] = entry;
     table->entry_count++;
 
+    /* #682: parallel per-document chain — teardown walks exactly
+     * this doc's entries instead of scanning the whole table. */
+    if (doc) {
+        entry->doc_next =
+            (struct leptris_compact_overflow_entry*)doc->overflow_entries;
+        doc->overflow_entries = entry;
+    }
+
     if (table->entry_count >= table->bucket_count) {
         overflow_table_grow(table);
     }
@@ -208,26 +217,40 @@ void leptris_compact_cleanup(void) {
 void leptris_compact_cleanup_document(struct leptris_document* doc) {
     if (!doc || !g_overflow_table) return;
 
-    size_t removed_count = 0;
+    /* #682: walk THIS document's entry chain (linked at set time)
+     * instead of scanning every bucket of the global table — the
+     * old full-table sweep ran on every document free and dominated
+     * apply-heavy XSLT profiles (result docs register thousands of
+     * cross-block edge entries; the sampler pinned 35% of the
+     * dispatch bench in this loop). */
+    LeptrisCompactOverflowEntry* e =
+        (LeptrisCompactOverflowEntry*)doc->overflow_entries;
+    doc->overflow_entries = NULL;
 
-    for (size_t i = 0; i < g_overflow_table->bucket_count; i++) {
-        LeptrisCompactOverflowEntry** entry_ptr = &g_overflow_table->buckets[i];
-        LeptrisCompactOverflowEntry* entry = *entry_ptr;
-
-        while (entry) {
-            if (entry->doc == doc) {
-                /* Unlink only — entries live in SLABS owned by the
-                 * table; free()ing them corrupted the heap whenever
-                 * a document had overflow entries (common since the
-                 * #450 sibling-edge work routed far links here). */
-                *entry_ptr = entry->next;
-                entry = *entry_ptr;
-                removed_count++;
-            } else {
-                entry_ptr = &entry->next;
-                entry = entry->next;
+    size_t removed_count = 0;
+    while (e) {
+        LeptrisCompactOverflowEntry* next = e->doc_next;
+        if (e->doc == doc) {
+            /* Stale chain links (entry re-registered under another
+             * doc) are skipped — the ->doc check keeps them alive
+             * for their true owner. */
+            size_t index = hash_pointer(e->key,
+                                        g_overflow_table->bucket_count);
+            LeptrisCompactOverflowEntry** entry_ptr =
+                &g_overflow_table->buckets[index];
+            while (*entry_ptr) {
+                if (*entry_ptr == e) {
+                    /* Unlink only — entries live in SLABS owned by
+                     * the table; free()ing them corrupted the heap
+                     * (#450 sibling-edge follow-up). */
+                    *entry_ptr = e->next;
+                    removed_count++;
+                    break;
+                }
+                entry_ptr = &(*entry_ptr)->next;
             }
         }
+        e = next;
     }
 
     g_overflow_table->entry_count -= removed_count;

data/vendor-src/libleptris/src/leptris/dom/compact.h

@@ -60,6 +60,9 @@ typedef struct leptris_compact_overflow_entry {
     void* value;                  /* Actual pointer value */
     struct leptris_document* doc;   /* Document that owns this entry */
     struct leptris_compact_overflow_entry* next;
+    /* #682: per-document chain — teardown walks THIS doc's entries
+     * instead of scanning every bucket of the global table. */
+    struct leptris_compact_overflow_entry* doc_next;
 } LeptrisCompactOverflowEntry;
 
 /**

data/vendor-src/libleptris/src/leptris/dom/element.c

@@ -979,7 +979,12 @@ static size_t calculate_text_length_recursive(LeptrisNode* node) {
              * text->content_len directly. */
             const char* content = leptris_text_get_content(text);
             if (content) {
-                len += strlen(content);
+                /* #1285 slice 1: frozen (parse-created,
+                 * immutable) texts carry an authoritative
+                 * content_len — skip the scan. */
+                size_t clen = child->frozen ? text->content_len
+                                            : strlen(content);
+                len += clen;
             }
         } else if (child->type == LEPTRIS_NODE_TYPE_CDATA) {
             LeptrisCDATANode* cdata = (LeptrisCDATANode*)child;
@@ -1013,7 +1018,10 @@ static void copy_text_content_recursive(LeptrisNode* node, char* result, size_t*
             LeptrisTextNode* text = (LeptrisTextNode*)child;
             const char* content = leptris_text_get_content(text);
             if (content) {
-                size_t clen = strlen(content);
+                /* #1285 slice 1: frozen texts — authoritative
+                 * content_len (mirrors the length pass). */
+                size_t clen = child->frozen ? text->content_len
+                                            : strlen(content);
                 memcpy(result + *offset, content, clen);
                 *offset += clen;
             }

data/vendor-src/libleptris/src/leptris/dom/text.c

@@ -102,6 +102,16 @@ const char* leptris_text_get_content(LeptrisTextNode* text) {
     if (!text) return NULL;
 
     if (text->borrowed && text->pool) {
+        /* #1218 slice 2: an in-place terminated run (the parser
+         * wrote the NUL into the doc-owned input copy) is already
+         * materialized — serve it directly when it carries no
+         * entity. A run WITH '&' still takes the expansion path
+         * below (dp-borrowed nodes rely on it). */
+        if (text->content_len > 0 &&
+            text->content[text->content_len] == '\0' &&
+            memchr(text->content, '&', text->content_len) == NULL) {
+            return text->content;
+        }
         /* Entity expansion: if the borrowed content contains '&',
          * expand predefined XML entities (&, <, etc.) and
          * numeric character references (A, B) into a new