leptris 1.9.287.0-ppc64le-linux → 1.9.290.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c75b5c08c95ae3b7bad54696d4689aeb99203ea67fe5d122fe7617f2d9cad48
-  data.tar.gz: 27edf2484a9d4897cad4ae2415ee61b40a0d039fdcac6021d3c859805b055611
+  metadata.gz: 505fb9e6093b335b955a6c776e97beb0cd43d9e498d8f44333b3faccc93bee26
+  data.tar.gz: 69b07068ad720f0da28fbc713625884621cf067a0fe0134b88bed2eba8549fa5
 SHA512:
-  metadata.gz: 13f21fd7388db204aad1adf676cd6fec3c9e03870270075f05f10a0fa16ca1154ee2950dea81fb7bc40029508e742089ccb866b2a1c466bf347d39259c396fb2
-  data.tar.gz: 7a261ed53220fbeef6006cd7a69548088ac9bb89d5ba43102319608c460c9882320b62dee3afdc87b9c9e36b9a4b921207e3ebfbb9e5ea1f6589e2dfdabfc1ab
+  metadata.gz: aba2088b46d2f97563715259e4a8c8f12fa49f5918a42272f849c64030aad24fa0051449e9f29a0e90c5f7e118be49cc8dc9eae14f4575f4c7552c524715205c
+  data.tar.gz: ea9d90fb9c71b40bcd3692b81d138752a9e4d5aca9943baa6f6a62769f1136773cb0b54e28ed36e0c7ca4a46c7e40b874351f4d76ebdbf227d64611f38502bad

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.287"
+LIBLEPTRIS_VERSION = "1.9.290"
 # 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.287.0"
+  VERSION = "1.9.290.0"
 end

data/lib/leptris/xml/descriptor.rb

@@ -167,6 +167,18 @@ class Leptris::XML::Descriptor
         ap[:wire_name] = anchor_string(anchors, row.fetch(:name))
         ap[:kind] = kind_code(row[:kind] || :scalar)
         ap[:type_tag] = type_tag_code(row)
+        # Attribute-level namespace form (libleptris 1.9.289, #1486):
+        # ns rows match by (URI, local) — the wire prefix is irrelevant.
+        # Mirrors the child-row packing.
+        ap[:ns_form] =
+          case row[:ns]
+          when :any then Leptris::XML::FFI::PLAN_NS_ANY
+          when Hash  then Leptris::XML::FFI::PLAN_NS_EXACT
+          else         Leptris::XML::FFI::PLAN_NS_NONE
+          end
+        ap[:ns_uri] =
+          row[:ns].is_a?(Hash) ?
+            anchor_string(anchors, row[:ns].fetch(:exact)) : nil
         pack_predicates(ap, row, anchors)
       end
       ep[:attribute_count] = attrs.size

data/lib/leptris/xml/ffi.rb

@@ -299,7 +299,13 @@ module Leptris
                :type_tag, :uint8,
                :predicate_count, :uint16,
                :pad_pred, :uint16,
-               :predicates, :pointer
+               :predicates, :pointer,
+               # libleptris 1.9.289 (#1486): attribute-level namespace
+               # form — ns rows match by (URI, local), wire_name is the
+               # LOCAL name; NONE keeps wire-name-exact matching.
+               :ns_form, :uint8,
+               :pad_ns, :uint8,
+               :ns_uri, :pointer
       end
       class ChildPlan < ::FFI::Struct
         layout :wire_name, :pointer,

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.287
+- libleptris v1.9.290
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,37 @@
 ## [Unreleased]
 
+## [1.9.290] - 2026-10-02
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Added
+
+- namespace forms for attribute plan rows — `ns_form`/`ns_uri` on `leptris_attr_plan` (#1486)
+  - Extends #1115's child-row pattern to attribute rows: `ns_form = 0` (the zero value) keeps the historical wire-name lookup byte-for-byte and existing aggregate initializers stay valid; `LEPTRIS_PLAN_NS_EXACT` + `ns_uri` makes `wire_name` the LOCAL name and binds the (namespace URI, local) identity through the element's in-scope prefix bindings — prefix-spelling-independent, so a `w14:paraId`-typed row binds whatever prefix the document uses for the Word 2010 URI. `LEPTRIS_PLAN_NS_ANY` matches the local name in any namespace; unprefixed attributes have no namespace and never bind EXACT (XML Namespaces §5.2).
+  - Unlocks the plan fast path for typed-attribute models: lutaml-model's `attr_type_ns` opt-out (one `w14:paraId` leaf cascading the WordprocessingML paragraph chain out of the plan path, against a measured 33% parse-CPU saving) can now emit ns-exact attribute rows instead.
+  - Build deep-copies `ns_uri`, zero-guards the trailing fields for hosts that `malloc` the spec without value-initialization (#1272 lesson), rejects `EXACT` without a URI as `INVALID_ARG`; free releases the copies. RED-first spec plus the full battery (1773/1773). (#1487)
+
+## [1.9.289] - 2026-10-02
+
+### Performance
+
+- open-id compares for the scope/table-context stack walks (#1218 slice 6, tranche 2) (html)
+  - The scope walks (p-in-button-scope, button-in-scope, AFE `kn`), the table-context searches, and the table-context dispatch block compare `b->open_id[k]` integers instead of fetching the element name and running case-insensitive literal chains per stack slot. The AFE furthest-block scan deliberately keeps the name fetch — it runs mid-AFE between stack splices, where the id stack is not yet authoritative (webkit02:14). Interleaved A/B vs the tranche-1 tree: 48.2-53.7 -> 51.0-58.2 MB/s (+11% median) on the 2.6MB table-rows shape. (#1485)
+- id-LUT membership for the foster/formatting/stack checks (#1218 slice 6) (html)
+  - The classifier table grows the 22 compared-but-unlisted names (HTML4 formatting set + MathML/SVG integration points, inert flags); `h_is_formatting` (14-way) and `h_fosterable` (15-way) become id-LUT lookups; 15 insertion-mode stack checks read `open_id[]` directly. 56.1 -> 59.0 MB/s (+5.2%) interleaved. Cumulative slice 6: ~+15% on the issue's fixture shape; the 3.4-7x deficit the issue reported at 1.9.203 is now a 1.3-1.55x LEAD over htmlReadMemory locally. (#1484)
+
+
+
+## [1.9.288] - 2026-10-02
+
+### Fixed
+
+- top-level param values are XPath expressions (libxslt convention) — follow-up to #1478 (xslt)
+  - **Semantics correction to `leptris_xslt_apply_params` / `leptris_xslt_apply_string_params`, released briefly in 1.9.287:** value strings are now evaluated as XPath EXPRESSIONS (libxslt `params` convention; nokogiri's `quote_params` exists for exactly this), not bound as raw strings. Callers pass quoted literals — `{"n", "'7'"}` binds the string `7`; under 1.9.287 the quotes were part of the value. Numbers and source-derived expressions work (`7 * 6` → 42, `string(/r/@v)`), a later pair may reference an earlier one, a global `xsl:variable` may consume a caller value (§11 ordering), undeclared names bind into scope (libxslt parity), and a malformed expression fails the transform. Caller values bind before the globals run and a declared `xsl:param` default whose name a caller supplied never evaluates (§11.4). Specs ported from #1478 plus three RED-first expression cases; 1771/1771 and an external-consumer end-to-end probe. (#1481)
+
+
+
 ## [1.9.287] - 2026-10-02
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/include/leptris/descriptor.h

@@ -95,6 +95,18 @@ typedef struct {
     uint16_t predicate_count;
     uint16_t pad_pred;
     const leptris_attr_predicate* predicates;
+    /* #1486 (additive trailing fields, the #1115 child-row
+     * pattern): attribute-level namespace form. A row with
+     * ns_form set matches by (namespace URI, local name) —
+     * wire_name is the LOCAL name and the prefix spelling on the
+     * wire is irrelevant. NONE (0, the zero value) keeps the
+     * historical behavior: lookup by wire_name exactly as it
+     * appears on the wire (prefixed or bare). Unprefixed
+     * attributes have no namespace; EXACT requires a prefixed
+     * attribute whose prefix binds to ns_uri. */
+    uint8_t ns_form;       /* LeptrisPlanNsForm */
+    uint8_t pad_ns;
+    const char* ns_uri;    /* LEPTRIS_PLAN_NS_EXACT only */
 } leptris_attr_plan;
 
 typedef struct {

data/vendor-src/libleptris/src/include/leptris.h

@@ -3096,20 +3096,6 @@ LEPTRIS_API void leptris_xslt_free(LeptrisXslt xslt);
  */
 LEPTRIS_API LeptrisDocument leptris_xslt_apply(LeptrisXslt xslt,
                                                 LeptrisDocument doc);
-/**
- * Apply a compiled stylesheet with top-level xsl:param overrides
- *
- * `pairs` is a flat name/value array: 2*pair_count entries,
- * pairs[2*i] is the param name, pairs[2*i+1] its string value
- * (bound as an XPath string — consumers doing numeric quoting own
- * that, matching libxslt conventions). A supplied name never
- * evaluates the param's select/@default; absent names keep them.
- * The array is borrowed for the duration of the call only.
- */
-LEPTRIS_API LeptrisDocument leptris_xslt_apply_params(
-    LeptrisXslt xslt, LeptrisDocument doc,
-    const char* const* pairs, size_t pair_count);
-
 /**
  * Apply a compiled stylesheet and serialize the result
  *
@@ -3123,15 +3109,50 @@ LEPTRIS_API LeptrisDocument leptris_xslt_apply_params(
  */
 LEPTRIS_API char* leptris_xslt_apply_string(LeptrisXslt xslt,
                                              LeptrisDocument doc);
+
+/**
+ * Apply a compiled stylesheet with caller-supplied top-level params
+ *
+ * Binds the given xsl:param values BEFORE the stylesheet's globals
+ * run (XSLT §11.4): a caller value replaces the declared default,
+ * unspecified params keep their defaults, and the value expressions
+ * may reference the source document and earlier pairs.
+ *
+ * pairs is a flat name/value array — [name0, value0, name1,
+ * value1, ...] — and count is the number of PAIRS (the array holds
+ * 2*count entries). Each value is an XPath EXPRESSION evaluated
+ * with the source document node as context; callers pre-quote
+ * string literals ("'text'"), matching the libxslt convention.
+ *
+ * @param xslt Compiled stylesheet
+ * @param doc Source document (not modified)
+ * @param pairs Flat name/expression array, or NULL with count 0
+ * @param count Number of name/expression pairs
+ * @return Result tree (free with leptris_document_free), or NULL on
+ *         error — including a value expression that fails to
+ *         compile (message via leptris_document_last_error)
+ */
+LEPTRIS_API LeptrisDocument leptris_xslt_apply_params(
+    LeptrisXslt xslt, LeptrisDocument doc,
+    const char* const* pairs, size_t count);
+
 /**
- * Apply with top-level param overrides and serialize the result
+ * Apply with caller-supplied top-level params and serialize
+ *
+ * leptris_xslt_apply_params + the leptris_xslt_apply_string
+ * serialization contract (top-level text nodes and fragments
+ * preserved).
  *
- * Same pair encoding and semantics as leptris_xslt_apply_params;
- * leptris_xslt_apply_string otherwise.
+ * @param xslt Compiled stylesheet
+ * @param doc Source document
+ * @param pairs Flat name/expression array (see
+ *        leptris_xslt_apply_params), or NULL with count 0
+ * @param count Number of name/expression pairs
+ * @return Serialized result (free with leptris_free_string), or NULL
  */
 LEPTRIS_API char* leptris_xslt_apply_string_params(
     LeptrisXslt xslt, LeptrisDocument doc,
-    const char* const* pairs, size_t pair_count);
+    const char* const* pairs, size_t count);
 
 /**
  * Custom XPath function handler (string-valued).

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

@@ -246,6 +246,7 @@ static void dp_plan_free(LeptrisPlan p) {
         dp_plan* d = &p->plans[i];
         for (uint32_t a = 0; a < d->attribute_count; a++) {
             free((char *)d->attribute_plans[a].wire_name);
+            free((char *)d->attribute_plans[a].ns_uri);
             for (uint16_t pi = 0;
                  pi < d->attribute_plans[a].predicate_count; pi++) {
                 free((char*)d->attribute_plans[a]
@@ -332,6 +333,32 @@ LEPTRIS_API LeptrisPlan leptris_plan_build(const leptris_plan_spec* spec,
                     d->attribute_plans[a].predicate_count = 0;
                     d->attribute_plans[a].pad_pred = 0;
                 }
+                /* #1486 additive-ABI guard (the #1272 lesson): a
+                 * host that mallocs the spec leaves the trailing
+                 * ns fields garbage — normalize unset forms so the
+                 * walker never reads a garbage pointer, and deep-
+                 * copy EXACT uris. EXACT without a uri cannot
+                 * express an identity: reject the spec. */
+                if (!s->attribute_plans[a].ns_form) {
+                    d->attribute_plans[a].ns_form = 0;
+                    d->attribute_plans[a].pad_ns = 0;
+                    d->attribute_plans[a].ns_uri = NULL;
+                } else {
+                    d->attribute_plans[a].pad_ns = 0;
+                    if (s->attribute_plans[a].ns_form ==
+                            LEPTRIS_PLAN_NS_EXACT) {
+                        if (!s->attribute_plans[a].ns_uri) {
+                            if (status) *status = LEPTRIS_ERROR_INVALID_ARG;
+                            dp_plan_free(p);
+                            return NULL;
+                        }
+                        d->attribute_plans[a].ns_uri =
+                            dp_strdup(s->attribute_plans[a].ns_uri);
+                        if (!d->attribute_plans[a].ns_uri) goto oom;
+                    } else {
+                        d->attribute_plans[a].ns_uri = NULL;
+                    }
+                }
                 if (s->attribute_plans[a].wire_name) {
                     d->attribute_plans[a].wire_name =
                         dp_strdup(s->attribute_plans[a].wire_name);
@@ -491,6 +518,50 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
                             const LeptrisPlan pool,
                             struct leptris_plan_result* out);
 
+/* #1486 attribute-row binding. ns_form 0 = the historical
+ * wire-name lookup (the string exactly as it appears on the
+ * wire). A set form matches (namespace, local): the row's
+ * wire_name is the LOCAL name; each attribute's prefix resolves
+ * through the ELEMENT's in-scope bindings, so the identity holds
+ * across prefix spellings. Unprefixed attributes have no
+ * 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);
+    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) continue;
+        const char* uri = NULL;
+        if (colon) {
+            char prefix[128];
+            size_t plen = (size_t)(colon - qn);
+            if (plen >= sizeof(prefix)) continue;
+            memcpy(prefix, qn, plen);
+            prefix[plen] = 0;
+            uri = leptris_element_namespace_for_prefix(elem, prefix);
+        }
+        switch (ap->ns_form) {
+            case LEPTRIS_PLAN_NS_NONE:
+                if (uri) continue;
+                break;
+            case LEPTRIS_PLAN_NS_EXACT:
+                if (!uri || !ap->ns_uri ||
+                    strcmp(uri, ap->ns_uri) != 0)
+                    continue;
+                break;
+            default: /* ANY */
+                break;
+        }
+        return leptris_attribute_get_value(elem, at);
+    }
+    return NULL;
+}
+
 static struct leptris_plan_result* dp_walk_element(LeptrisElement elem,
                                                    const dp_plan* plan,
                                                    const LeptrisPlan pool) {
@@ -510,7 +581,7 @@ static struct leptris_plan_result* dp_walk_element(LeptrisElement elem,
         for (uint32_t a = 0; a < plan->attribute_count; a++) {
             const leptris_attr_plan* ap = &plan->attribute_plans[a];
             if (!ap->wire_name) continue;
-            const char* val = leptris_element_attribute(elem, ap->wire_name);
+            const char* val = dp_attr_value(elem, ap);
             if (!val) continue;
             v->attr_names[v->attr_count] = dp_strdup(ap->wire_name);
             v->attr_values[v->attr_count] = dp_strdup(val);