leptris 1.9.399.0-arm-linux → 1.9.401.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85e3d9f5b990ac287799605ca5cd9054c9e7dd682d482af346ac1db782a26e1b
-  data.tar.gz: 8895a0750efb957fe2de60a932095e53345860eb448da621199a922fb38ab372
+  metadata.gz: c107bf6982053d9a85a433e49e16436cf38c93ef390fcb11069642bd507255cb
+  data.tar.gz: '0349bd09652826c6ac93638d751b743c60d687dd20679aeebf6e12dca0477edc'
 SHA512:
-  metadata.gz: 333f9d60f1197ea4db616adbbfc9db96abdf6cca1a8e17abf1d6afbc7d798d0a69b7cf504bbecb2e22cd44e1c72de00cf9a50c38e50bab032ea1356526d22126
-  data.tar.gz: 608657836bc76cb63eb79466b06d9e6f93862dd63c44b3e5bc19a77fcbb6b51f81c4f2594f4e98607353342dd064da56cf78d96335a5b9bc690eed9f15bc8374
+  metadata.gz: c3de4ef23793319525120a22edd38087087bc726579eff905dcb63cc3a75fd05a214b94dd80fb7bcae66186fe27e9b09db1aa33da79a1c05d4f5b37a4d8206e9
+  data.tar.gz: c8b03b880fc5bc05fece37578f53d265cf3c3c7ec041c88dc46180d67c3462bea01f46d460210340784eeb116464933dc0f6fe82c24e4d426bf1220d316f9eea

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.399"
+LIBLEPTRIS_VERSION = "1.9.401"
 # 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.399.0"
+  VERSION = "1.9.401.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.399
+- libleptris v1.9.401
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,41 @@
 ## [Unreleased]
 
+## [1.9.401] - 2026-11-01
+
+### Fixed
+
+- **List value spaces collapse whitespace before the facets
+  (leptris#1936 stG010/stH005, PR #1945).** Caught by running the
+  REAL W3C suite documents (vendored in lutaml-xsd) through the
+  xmllint-arbiter harness: a list-derived restriction's
+  enumeration facet compared the RAW element content — stG010's
+  value arrives as newline-tab-CA-newline-spaces and never matched
+  enum "CA" — and a whole-list pattern had the same hole (stH005).
+  List value spaces are whitespace=collapse (Part 2): the value is
+  normalized before the pattern/enumeration/length family runs.
+  Suite 142/142; both documents validate. (xsd)
+
+
+
+## [1.9.400] - 2026-11-01
+
+### Fixed
+
+- **A restriction's inline anonymous base drives validation
+  (leptris#1936 stG/stH, PR #1943).** An `xs:restriction` whose
+  base is an inline anonymous `<xs:simpleType>` — the W3C suite's
+  stG/stH style — never captured that base: values were
+  facet-checked with nothing underneath, so `length` counted
+  characters of the whole lexical instead of list items. The base
+  now rides the capture (`base_def`, mirroring `item_def`/
+  `member_defs`), the value passes through the base's own
+  derivation before the restriction's facets, and the list-chain
+  detector descends the anonymous path. RED-first spec; the
+  xmllint-arbiter harness agrees on all 8 collected
+  schema/instance pairs. (xsd)
+
+
+
 ## [1.9.399] - 2026-10-31
 
 ### Fixed

data/vendor-src/libleptris/CLAUDE.md

@@ -169,3 +169,19 @@ calculates the next version, and updates three files:
 - `CHANGELOG.md` (version header)
 
 The bump-version.sh script handles all three in one shot.
+
+### Runtime coverage law: publish ALL runtimes every release
+
+An engine release is NOT done when the GitHub Release publishes — it is
+done when every runtime package riding it is published and VERIFIED on
+its registry, same day: **ruby** (rubygems, leptris-ruby: bump Rakefile
+`LIBLEPTRIS_VERSION` + `lib/leptris/version.rb`; merge = publish), **py**
+(PyPI, leptris-py: bump `libleptris-version.txt` + `pyproject.toml` +
+`leptris/__init__.py`; merge = publish), **rs** (crates.io, leptris-rs:
+conventional commits -> merge release-plz's release PR = publish), **ts**
+(npm package `leptris`, leptris-ts: bump pin + `package.json`; the
+`v<pkg>` tag push publishes). Verify on the registry itself — a merged
+PR with a stuck workflow is not a release (2026-10-29: ruby sat two
+engine releases behind with the pin already advanced; py seven behind;
+rs's release workflow had never succeeded — missing `id-token: write`;
+ts 0.1.24 never tagged).

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/README.adoc

@@ -1172,6 +1172,53 @@ No runtime dependencies when built without utf8proc/iconv.
 |libFuzzer for 5 minutes; report any crashes.
 |===
 
+== Releasing and the runtime packages
+
+The engine releases via the automated workflow
+(`gh workflow run release.yml -f next_version=patch` — the workflow
+bumps the version, opens the release PR, and tags + publishes the
+GitHub Release when it merges). Never tag or release by hand.
+
+**Every engine release ships ALL runtime packages the same day** —
+an engine release is not done until each binding that rides it is
+published and verified on its registry:
+
+[cols="1,2,3",options="header"]
+|===
+|Runtime |Registry |Ride
+
+|Ruby
+|rubygems (`leptris`, `{engine-semver}.{binding-patch}`)
+|bump `Rakefile` `LIBLEPTRIS_VERSION` + `lib/leptris/version.rb` in
+link:https://github.com/leptris/leptris-ruby[leptris-ruby]; merging
+the bump PR is the release decision (auto-publish).
+
+|Python
+|PyPI (`leptris`)
+|bump `libleptris-version.txt` + `pyproject.toml` +
+`leptris/__init__.py` in
+link:https://github.com/leptris/leptris-py[leptris-py]; merging the
+bump PR publishes via trusted publishing.
+
+|Rust
+|crates.io (`leptris`)
+|conventional commits on
+link:https://github.com/leptris/leptris-rs[leptris-rs] main; the
+release-plz PR carries the version bump, and merging IT publishes
+(crates.io trusted publishing).
+
+|TypeScript / WASM
+|npm (`leptris`)
+|bump the engine pin + `package.json` version in
+link:https://github.com/leptris/leptris-ts[leptris-ts]; the
+tag-gated `v<pkg-version>` push publishes via npm trusted
+publishing.
+|===
+
+Verify each publication on the registry itself (`gem list -r`,
+`pip index versions`, the crates.io/npm APIs) — a merged PR with a
+stuck workflow is NOT a release.
+
 == Project layout
 
 [source,text]

data/vendor-src/libleptris/src/leptris/xsd/compile.c

@@ -428,6 +428,22 @@ static XsdSimple* xsd_capture_simple(LeptrisElement st) {
         } else if (strcmp(local, "restriction") == 0) {
             simple->base = xsd_strdup(xsd_local_name(
                 leptris_element_attribute(e, "base")));
+            /* #1936 (stG/stH): an inline anonymous BASE rides this
+             * capture — without it the restriction's facets apply
+             * with no base (length counted characters, list
+             * semantics vanished). Mirrors the union member_defs. */
+            for (LeptrisNodeRef b = leptris_node_first_child(
+                     leptris_element_as_node(e));
+                 b && !simple->base_def;
+                 b = leptris_node_next_sibling(b)) {
+                if (leptris_node_get_type(b) != LEPTRIS_NODE_TYPE_ELEMENT)
+                    continue;
+                LeptrisElement be = (LeptrisElement)b;
+                const char* bl = NULL;
+                leptris_element_expanded_name(be, &bl, NULL, NULL);
+                if (bl && strcmp(bl, "simpleType") == 0)
+                    simple->base_def = xsd_capture_simple(be);
+            }
             for (LeptrisNodeRef f = leptris_node_first_child(
                      leptris_element_as_node(e));
                  f; f = leptris_node_next_sibling(f)) {
@@ -584,7 +600,13 @@ static int xsd_chain_is_list(struct leptris_xsd_schema* s,
     int depth = 0;
     while (t && depth < 32) {
         if (t->deriv == XSD_SIMPLE_LIST) return 1;
-        if (!t->base) return 0;
+        if (!t->base) {
+            /* #1936: an anonymous inline base continues the chain —
+             * a restriction of an inline list keeps list semantics
+             * (the length family counts items). */
+            if (t->base_def) { t = t->base_def; depth++; continue; }
+            return 0;
+        }
         if (strncmp(t->base, "xs:", 3) == 0)
             return strcmp(t->base, "xs:IDREFS") == 0 ||
                    strcmp(t->base, "xs:NMTOKENS") == 0 ||
@@ -651,6 +673,11 @@ static int xsd_deriv_valid(struct leptris_xsd_schema* s,
                 return 1;
         return 0;
     }
+    /* #1936: the value satisfies the inline base (its own
+     * derivation — list item walks, union members — first), then
+     * this level's facets. */
+    if (t->base_def && !xsd_deriv_valid(s, t->base_def, v, depth + 1))
+        return 0;
     return xsd_simple_valid(t, v, xsd_chain_terminal(s, t), 0);
 }
 
@@ -663,6 +690,11 @@ static int xsd_valid_chain(struct leptris_xsd_schema* s,
     }
     if (t->deriv != XSD_SIMPLE_RESTRICT)
         return xsd_deriv_valid(s, t, v, depth);
+    /* #1936: the inline anonymous base drives the value first
+     * (its own derivation — list item walks, union members),
+     * then this restriction's facets. */
+    if (t->base_def && !xsd_deriv_valid(s, t->base_def, v, depth + 1))
+        return 0;
     return xsd_simple_valid(t, v, xsd_chain_terminal(s, t),
                             xsd_chain_is_list(s, t));
 }
@@ -2551,6 +2583,7 @@ static void xsd_free_simple_one(XsdSimple* t) {
     free(t->assertion);
     free(t->item_type);
     xsd_free_simple_one(t->item_def);
+    xsd_free_simple_one(t->base_def);
     for (size_t i = 0; i < t->member_count; i++) free(t->members[i]);
     free(t->members);
     for (size_t i = 0; i < t->member_def_count; i++)

data/vendor-src/libleptris/src/leptris/xsd/datatypes.c

@@ -510,7 +510,41 @@ static int facet_check_body(const XsdSimple* s, const char* v,
                             const char* terminal_base, int chain_is_list);
 static int facet_check(const XsdSimple* s, const char* v,
                        const char* terminal_base, int chain_is_list) {
-    int rc = facet_check_body(s, v, terminal_base, chain_is_list);
+    /* #1936 (stG010): a LIST value space is whitespace=collapse —
+     * element content arrives as "\n\tCA\n  " and the enumeration
+     * /pattern facets must see the collapsed form ("CA"), not the
+     * raw text. */
+    int list_valued = chain_is_list || s->deriv == XSD_SIMPLE_LIST ||
+        (terminal_base &&
+         (strcmp(terminal_base, "xs:IDREFS") == 0 ||
+          strcmp(terminal_base, "xs:NMTOKENS") == 0 ||
+          strcmp(terminal_base, "xs:ENTITIES") == 0));
+    if (!list_valued)
+        return facet_check_body(s, v, terminal_base, chain_is_list);
+    while (*v == ' ' || *v == '\t' || *v == '\n' || *v == '\r') v++;
+    size_t n = strlen(v);
+    while (n > 0 && (v[n-1] == ' ' || v[n-1] == '\t' ||
+                     v[n-1] == '\n' || v[n-1] == '\r'))
+        n--;
+    char* collapsed = (char*)malloc(n + 1);
+    if (!collapsed)
+        return facet_check_body(s, v, terminal_base, chain_is_list);
+    size_t o = 0;
+    int in_ws = 0;
+    for (size_t i = 0; i < n; i++) {
+        char ch = v[i];
+        if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') {
+            if (!in_ws && o) collapsed[o++] = ' ';
+            in_ws = 1;
+        } else {
+            collapsed[o++] = ch;
+            in_ws = 0;
+        }
+    }
+    if (o && collapsed[o-1] == ' ') o--;
+    collapsed[o] = 0;
+    int rc = facet_check_body(s, collapsed, terminal_base, chain_is_list);
+    free(collapsed);
     return rc;
 }
 static int facet_check_body(const XsdSimple* s, const char* v,

data/vendor-src/libleptris/src/leptris/xsd/xsd_internal.h

@@ -40,6 +40,7 @@ typedef struct xsd_simple {
     char* name;
     char* ns;    /* leptris-ruby#440: declaring schema's targetNamespace */
     char* base;
+    struct xsd_simple* base_def; /* RESTRICTION: inline anonymous base */
     XsdSimpleDeriv deriv;
     char* item_type;         /* LIST: builtin or local type name */
     struct xsd_simple* item_def; /* LIST: inline anonymous item type */

data/vendor-src/libleptris/test/xsd/test_xsd_compile.cpp

@@ -390,6 +390,53 @@ TEST(XsdDatatypes, LengthFacetCountsOctetsForHexBinary) {
 // byte world and character-class SUBTRACTION — the OPC
 // ST_ContentType shape. A pattern that fails to parse rejects
 // everything, so media types failed wholesale.
+// leptris#1936 (stG/stH oracle pair): a restriction whose base is
+// an ANONYMOUS inline simpleType must validate the value against
+// that base before its own facets — length on a list-with-length-2
+// counts items, not characters of the whole lexical.
+// leptris#1936 (stG010/stH005, the REAL suite documents): a list
+// value space is whitespace=collapse — element content "\n\tCA\n  "
+// normalizes to "CA" before the enumeration/pattern facets run.
+TEST(XsdDatatypes, ListValueSpaceCollapsesBeforeFacets) {
+    const char xsd[] =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:simpleType name=\"myToken\"><xs:list itemType=\"xs:NMTOKEN\"/>"
+        "</xs:simpleType>"
+        "<xs:simpleType name=\"fooType\"><xs:restriction base=\"myToken\">"
+        "<xs:enumeration value=\"CA\"/><xs:enumeration value=\"OR\"/>"
+        "</xs:restriction></xs:simpleType>"
+        "<xs:element name=\"r\" type=\"fooType\"/></xs:schema>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_EQ(st, LEPTRIS_OK);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "fooType", "\n\tCA\n  "), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "fooType", "CA"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "fooType", "  OR  "), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "fooType", "CA OR"), 0);
+    leptris_xsd_free(s);
+}
+
+TEST(XsdDatatypes, RestrictionInlineBaseDrivesFacets) {
+    const char xsd[] =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:simpleType name=\"twoInts\"><xs:restriction>"
+        "<xs:simpleType><xs:list itemType=\"xs:int\"/></xs:simpleType>"
+        "<xs:length value=\"2\"/></xs:restriction></xs:simpleType>"
+        "<xs:element name=\"r\" type=\"twoInts\"/></xs:schema>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_EQ(st, LEPTRIS_OK);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    // 2 items: valid per xmllint (the engine used to count chars)
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "twoInts", "1 2"), 1);
+    // 3 items: over the length facet
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "twoInts", "1 2 3"), 0);
+    // a member fails the item type
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "twoInts", "1 x"), 0);
+    leptris_xsd_free(s);
+}
+
 // leptris#1936 (reS38/reT51): XSD 1.0 cites Unicode 3.1, where
 // U+1369-1371 (Ethiopic digits one-nine) were Nd — \\d matches
 // &#x1371; and \\D rejects it even though the host tables (4.0.1+)

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.399",
+  "version": "1.9.401",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.399.0
+  version: 1.9.401.0
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-31 00:00:00.000000000 Z
+date: 2026-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi