leptris 1.9.319.0 → 1.9.320.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2249f8242e8a5d15ce4f661147bd4c6aecc64a0a8926e9601b0797299b1ea2c2
-  data.tar.gz: 4db6afad4fcb92cbb8dca44b44db3703fa7831b0a5bcbe6b545f1c7321da5375
+  metadata.gz: 7e309fd6444a641db0b0f24f92aef96097860678c006a217a783724c499b7f50
+  data.tar.gz: d041122c9d4d1b366549b4dd2d81c8e6c8ee226cc8ddee62d30a6f9a7a582458
 SHA512:
-  metadata.gz: 23e33b8150701da1f5535e9df6fe4d59a15f1255f3c8bfe4183e5391b6e717dfc6ee6946852fd19247f988ba2d255f86530bc8b020cd56befdb18e1174ffbdf1
-  data.tar.gz: 55899c894639282f6ce290e940f61daf8b1416bd7fee6cc24b2d758df21f0b8fa80246b830309a4b6a684dfe34ebfe3af887d8b462f738a13ef0936436c28b85
+  metadata.gz: ae5b672a25949b41161419054c7ba635e2d234a5ea635a195ad5002d2aeaff4a4c18c3b0e98af5c23cb09c1fc7cec6967e4e866ea4b96c44031e0422fe1545fd
+  data.tar.gz: 6f454b0ad8bc92f31196fca9eb28369118cfe9ed81a7ccff3563a9dd903345ff145cdcb9549bcb6efc7d087718f143e1338704f4d6fdd63face059b74369f97f

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [1.9.320.0] - 2026-10-08
+
+### Fixed — engine sync (libleptris 1.9.320)
+
+- **Exact-URI child rows survive build-anchor GC (#1585)**: the
+  engine's plan build let child-row `ns_uri` ride a pointer into
+  the caller's build buffers instead of deep-copying — bindings
+  GC their anchors after build, so exact-URI child rows
+  deterministically stopped matching (uniword's
+  dc:title/dc:creator/dc:description hydrated nil). The engine
+  retains the URI; pinned with build + GC + walk.
+- **Plain attribute rows match any qualification (#1586)**:
+  ns-unset attr rows try the exact wire spelling first, then any
+  qualification by local name (#758 parity) — plain rows bind
+  `w:name`/`w:val` exactly as the interpretive path does, top
+  level and nested; exact-URI rows keep their #1486 precedence.
+  Pinned at both depths.
+
 ## [1.9.319.0] - 2026-10-08
 
 ### Added — engine sync (libleptris 1.9.319)

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.319"
+LIBLEPTRIS_VERSION = "1.9.320"
 # 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.319.0"
+  VERSION = "1.9.320.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.319
+- libleptris v1.9.320
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## [Unreleased]
 
+## [1.9.320] - 2026-10-08
+
+### Fixed
+
+- **Descriptor: child-row exact-URI `ns_uri` retained at build
+  (#1585, PR #1587).** The build deep-copied child `ns_prefix` but
+  let `ns_uri` ride the struct copy — a pointer into the caller's
+  build buffers. Bindings GC their anchors (a warm walk plus one GC
+  makes it deterministic), after which exact-URI child rows
+  silently stopped matching and hydration answered nil (uniword's
+  `dc:title`/`dc:creator`/`dc:description`). The spec trashes the
+  caller's buffer after build and asserts the row still binds.
+- **Descriptor: plain attribute rows match any qualification
+  (#1586, PR #1587).** `dp_attr_value`'s ns-unset path now mirrors
+  #758 — the exact wire spelling first, then any qualification by
+  local name — so plain rows bind `w:name`/`w:val` exactly as the
+  interpretive path does, top level and nested. Exact-URI rows keep
+  their #1486 precedence. A NESTED row's binding also consults the
+  TARGET plan's `ns_lenient` now (the #1115-consistent authority)
+  instead of the outer plan's.
+
+
+
 ## [1.9.319] - 2026-10-08
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/leptris/descriptor/plan.c

@@ -285,6 +285,7 @@ static void dp_plan_free(LeptrisPlan p) {
         for (uint32_t c = 0; c < d->child_count; c++) {
             free((char *)d->child_plans[c].wire_name);
             free((char *)d->child_plans[c].ns_prefix);
+            free((char *)d->child_plans[c].ns_uri);
             for (uint16_t pi = 0;
                  pi < d->child_plans[c].predicate_count; pi++) {
                 free((char*)d->child_plans[c]
@@ -481,6 +482,15 @@ LEPTRIS_API LeptrisPlan leptris_plan_build(const leptris_plan_spec* spec,
                     sc->ns_prefix ? dp_strdup(sc->ns_prefix) : NULL;
                 if (sc->ns_prefix && !d->child_plans[c].ns_prefix)
                     goto oom;
+                /* #1585: ns_uri rides the struct copy otherwise —
+                 * a dangling pointer into the caller's build
+                 * buffers once they are reclaimed (bindings GC
+                 * their anchors; the descriptor must outlive
+                 * them). Same retention as attr rows (#1486). */
+                d->child_plans[c].ns_uri =
+                    sc->ns_uri ? dp_strdup(sc->ns_uri) : NULL;
+                if (sc->ns_uri && !d->child_plans[c].ns_uri)
+                    goto oom;
                 uint16_t pc = sc->predicate_count;
                 if (pc) {
                     if (!sc->predicates) goto oom;
@@ -598,8 +608,25 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
  * namespace (XML namespaces §5.2) — EXACT never binds them. */
 static const char* dp_attr_value(LeptrisElement elem,
                                  const leptris_attr_plan* ap) {
-    if (!ap->ns_form)
-        return leptris_element_attribute(elem, ap->wire_name);
+    if (!ap->ns_form) {
+        /* #1586, the plan-path mirror of #758: the exact wire
+         * spelling first, then any qualification by local name —
+         * plain rows are lenient exactly like element rows under
+         * ns_lenient. Exact-URI rows keep their #1486 semantics. */
+        const char* exact =
+            leptris_element_attribute(elem, ap->wire_name);
+        if (exact) return exact;
+        for (LeptrisAttribute at = leptris_element_first_attribute(elem);
+             at; at = leptris_attribute_next(at)) {
+            const char* qn = leptris_attribute_get_name(at);
+            if (!qn) continue;
+            const char* colon = strchr(qn, ':');
+            const char* local = colon ? colon + 1 : qn;
+            if (strcmp(local, ap->wire_name) == 0)
+                return leptris_attribute_get_value(elem, at);
+        }
+        return NULL;
+    }
     for (LeptrisAttribute at = leptris_element_first_attribute(elem);
          at; at = leptris_attribute_next(at)) {
         const char* qn = leptris_attribute_get_name(at);
@@ -832,8 +859,13 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
                 LeptrisElement child = (LeptrisElement)n;
                 if (!dp_wire_name_matches(child, row->wire_name))
                     continue;
+                /* The TARGET plan's form governs (#1115) — so its
+                 * lenient flag governs the leniency, not the outer
+                 * plan's (#1586: a namespaced child under a plan
+                 * that declares ns_lenient binds by local name). */
                 if (!dp_ns_binds(child, target->ns_form, target->ns_uri,
-                                 lenient))
+                                 (target->flags &
+                                  LEPTRIS_PLAN_FLAG_NS_LENIENT) != 0))
                     continue;
                 /* Claim the element against later same-wire rows
                  * (predicate partitioning). */

data/vendor-src/libleptris/test/abi/test_descriptor.cpp

@@ -1963,3 +1963,171 @@ TEST(Plan1563, PlainAttrRowAgreesNestedVsRoot) {
     leptris_plan_free(root_plan);
     leptris_plan_free(nested_plan);
 }
+
+// ---- #1585: child-row exact-URI ns_uri retention -------------------
+// The build copied child ns_prefix but left ns_uri pointing at the
+// CALLER's buffer — once the binding's build anchors are GC'd the
+// row dangles and silently stops matching. Retention is observable
+// without a GC: trash the caller's buffer after build; the row
+// must still bind.
+TEST(Plan1585, ChildRowNsUriIsRetained) {
+    LeptrisStatus st = LEPTRIS_OK;
+    char ns_uri_buf[64];
+    strcpy(ns_uri_buf, "http://purl.org/dc/elements/1.1/");
+
+    leptris_child_plan kids[2] = {};
+    kids[0].wire_name = "c";
+    kids[0].kind = LEPTRIS_PLAN_KIND_SCALAR;
+    kids[0].type_tag = 1;
+    kids[0].child_plan_index = -1;
+    kids[0].ns_form = LEPTRIS_PLAN_NS_EXACT;
+    kids[0].ns_uri = ns_uri_buf;
+    kids[0].ns_prefix = "d";
+    kids[1].wire_name = "p";
+    kids[1].kind = LEPTRIS_PLAN_KIND_SCALAR;
+    kids[1].type_tag = 2;
+    kids[1].child_plan_index = -1;
+    leptris_element_plan plans[1] = {};
+    plans[0].element_name = "r";
+    plans[0].ns_form = LEPTRIS_PLAN_NS_ANY;
+    plans[0].child_count = 2;
+    plans[0].child_plans = kids;
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 1;
+    spec.plans = plans;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+
+    /* Simulate the GC reclaiming the build anchor: the spec buffer
+     * is now garbage. */
+    memset(ns_uri_buf, 'X', sizeof(ns_uri_buf) - 1);
+
+    LeptrisDocument doc = parse(
+        "<r xmlns:d=\"http://purl.org/dc/elements/1.1/\">"
+        "<d:c>x</d:c><p>y</p></r>");
+    ASSERT_NE(doc, nullptr);
+    LeptrisPlanResult r =
+        leptris_plan_walk(doc, leptris_document_root(doc), plan, &st);
+    ASSERT_NE(r, nullptr);
+    ASSERT_EQ(leptris_plan_value_count(r), 2u);
+    EXPECT_STREQ(leptris_plan_value_string(leptris_plan_value_at(r, 0)),
+                 "x")
+        << "exact-URI child row lost its ns_uri";
+    EXPECT_STREQ(leptris_plan_value_string(leptris_plan_value_at(r, 1)),
+                 "y");
+    leptris_plan_result_free(r);
+    leptris_plan_free(plan);
+    leptris_document_free(doc);
+}
+
+// ---- #1586: plain attribute rows match any qualification -----------
+// The plan-path mirror of #758 (exact wire spelling first, then any
+// qualification by local name) — a plain attr row must bind w:name
+// the same way the interpretive path does, at top level and nested.
+TEST(Plan1586, PlainAttrRowLenientSpelling) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xml = "<r xmlns:w=\"http://w/1\" w:top=\"T\"/>";
+
+    leptris_attr_plan attrs[1] = {};
+    attrs[0].wire_name = "top";
+    attrs[0].kind = LEPTRIS_PLAN_KIND_SCALAR;
+    attrs[0].type_tag = 1;
+    leptris_element_plan plans[1] = {};
+    plans[0].element_name = "r";
+    plans[0].attribute_count = 1;
+    plans[0].attribute_plans = attrs;
+    plans[0].flags = LEPTRIS_PLAN_FLAG_NS_LENIENT;
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 1;
+    spec.plans = plans;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+
+    LeptrisDocument doc = parse(xml);
+    ASSERT_NE(doc, nullptr);
+    LeptrisPlanResult r =
+        leptris_plan_walk(doc, leptris_document_root(doc), plan, &st);
+    ASSERT_NE(r, nullptr);
+    EXPECT_STREQ(leptris_plan_value_attribute(r, "top"), "T");
+    leptris_plan_result_free(r);
+    leptris_document_free(doc);
+    leptris_plan_free(plan);
+}
+
+TEST(Plan1586, PlainAttrRowLenientUnderNestedRow) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xml = "<r xmlns:w=\"http://w/1\"><w:c w:n=\"N\"/></r>";
+
+    leptris_attr_plan c_attrs[1] = {};
+    c_attrs[0].wire_name = "n";
+    c_attrs[0].kind = LEPTRIS_PLAN_KIND_SCALAR;
+    c_attrs[0].type_tag = 1;
+    leptris_child_plan c_row = {};
+    c_row.wire_name = "c";
+    c_row.kind = LEPTRIS_PLAN_KIND_NESTED;
+    c_row.child_plan_index = 1;
+    c_row.ns_form = LEPTRIS_PLAN_NS_ANY;
+    leptris_element_plan plans[2] = {};
+    plans[0].element_name = "r";
+    plans[0].child_count = 1;
+    plans[0].child_plans = &c_row;
+    plans[1].element_name = "c";
+    plans[1].attribute_count = 1;
+    plans[1].attribute_plans = c_attrs;
+    plans[1].flags = LEPTRIS_PLAN_FLAG_NS_LENIENT;
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 2;
+    spec.plans = plans;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+
+    LeptrisDocument doc = parse(xml);
+    ASSERT_NE(doc, nullptr);
+    LeptrisPlanResult r =
+        leptris_plan_walk(doc, leptris_document_root(doc), plan, &st);
+    ASSERT_NE(r, nullptr);
+    ASSERT_EQ(leptris_plan_value_count(r), 1u);
+    LeptrisPlanResult child = leptris_plan_value_at(r, 0);
+    ASSERT_NE(child, nullptr);
+    EXPECT_STREQ(leptris_plan_value_attribute(child, "n"), "N");
+    leptris_plan_result_free(r);
+    leptris_document_free(doc);
+    leptris_plan_free(plan);
+}
+
+TEST(Plan1586, ExactUriRowStillWinsAndUnqualifiedStillBinds) {
+    LeptrisStatus st = LEPTRIS_OK;
+    /* exact-URI row keeps its #1486 semantics; unqualified wire
+     * attr binds a plain row by the literal spelling. */
+    const char* xml = "<r xmlns:w=\"http://w/1\" w:top=\"T\" top=\"U\"/>";
+    leptris_attr_plan exact[1] = {};
+    exact[0].wire_name = "top";
+    exact[0].kind = LEPTRIS_PLAN_KIND_SCALAR;
+    exact[0].type_tag = 1;
+    exact[0].ns_form = LEPTRIS_PLAN_NS_EXACT;
+    exact[0].ns_uri = "http://w/1";
+    leptris_element_plan plans[1] = {};
+    plans[0].element_name = "r";
+    plans[0].attribute_count = 1;
+    plans[0].attribute_plans = exact;
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 1;
+    spec.plans = plans;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+    LeptrisDocument doc = parse(xml);
+    ASSERT_NE(doc, nullptr);
+    LeptrisPlanResult r =
+        leptris_plan_walk(doc, leptris_document_root(doc), plan, &st);
+    ASSERT_NE(r, nullptr);
+    /* The qualified spelling carries "T"; the exact row must take
+     * it, not the unqualified "U". */
+    EXPECT_STREQ(leptris_plan_value_attribute(r, "top"), "T");
+    leptris_plan_result_free(r);
+    leptris_document_free(doc);
+    leptris_plan_free(plan);
+}

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.319",
+  "version": "1.9.320",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.319.0
+  version: 1.9.320.0
 platform: ruby
 authors:
 - Ribose Inc.