leptris 1.9.280.1 → 1.9.282.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8c9a359271bb60e62c4a6fb8e210c725d02b332df53f804411498c82acd1056
-  data.tar.gz: 5e196178a59975549b08e1c3b54c8d5377d463d430ad8bceef5df410a5ea4e83
+  metadata.gz: 2c255f7e95c4ff01c2ff315545555a81472e3f06fae61875db30357b92cb6644
+  data.tar.gz: bef13a2b8dab6c2fa220fa244dad937113db907f0cb15940bab2489c8d4c44e8
 SHA512:
-  metadata.gz: f4bbbdb0079f57fb234636a4ec03000a44a67ac6f80ea852fc4ba3bac9c0faddce6231900f137c8c9596369f4ea552120be792670da103f5169f2d796c891a56
-  data.tar.gz: 6a96c92cba79412fd69d32bc33482cd8b208808ded2b7d554539f7322647a9c6852e1531342fd428f7fe5826a94ccbfc428e4d094faca3d251dcdb2bddfb6aec
+  metadata.gz: aca607136b2b922b2b330ad743af2e7d847ad1ba0618d60dbdc4401addd0af2d496043d3a1eec2fac984a0934e8c1504a36d8b33b4113a260476f06ef50b442d
+  data.tar.gz: 43df939a0c758f17705fc2bff2628f00f0a3bb762e928fc8c61c0a6fabef85920b55a1c60bae98c08e17a674321187f4890bb519857a42b425a0795759b5e629

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## [1.9.282.0] - 2026-10-01
+
+### Fixed — engine sync (1.9.281)
+
+- Vendored libleptris 1.9.281: `fn:upper-case` and `fn:lower-case`
+  perform real Unicode case mapping (utf8proc per-codepoint
+  `toupper`/`tolower`) instead of ASCII-only `c ± 32` loops —
+  `upper-case(U+01CB)` correctly yields U+01CA.
+  `leptris_unicode_to_upper`/`to_lower` were case folding in
+  disguise and are rewritten as true case mapping;
+  `leptris_unicode_casecmp` keeps its genuine fold semantics
+  explicitly. Builds without utf8proc keep the ASCII fallback
+  (leptris#1182, leptris#1460).
+
+### Added — engine sync (1.9.281-1.9.282)
+
+- QT3 string-case corpus family adopted (leptris#1182): fn/upper-case
+  (23/30), fn/lower-case (23/28), fn/codepoint-equal (24/37); the
+  runner's corpus counts branch on the utf8proc capability.
+- QT3 string-tails batch 2: fn/encode-for-uri adopted — 25 of 30
+  cases run-and-agree, pinning the RFC 3986 %XX escaping behavior
+  as a permanent regression guard (leptris#1182, leptris#1462).
+
+
 ## [1.9.280.1] - 2026-09-30
 
 ### Added

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.280"
+LIBLEPTRIS_VERSION = "1.9.282"
 # 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.280.1"
+  VERSION = "1.9.282.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.280
+- libleptris v1.9.282
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,33 @@
 ## [Unreleased]
 
+## [1.9.282] - 2026-10-01
+
+### Added
+
+- QT3 string-tails batch 2: fn/encode-for-uri adopted — 25 of 30 cases run-and-agree on the
+  existing implementation (the remainder skip on unsupported environment shapes), pinning the
+  RFC 3986 %XX escaping behavior as a permanent regression guard (leptris#1182, leptris#1462).
+
+## [1.9.281] - 2026-09-30
+
+### Fixed
+
+- `fn:upper-case` and `fn:lower-case` now perform real Unicode case mapping (utf8proc's
+  per-codepoint `toupper`/`tolower`) instead of ASCII-only `c ± 32` loops — `upper-case(U+01CB)`
+  correctly yields U+01CA (fn-upper-case-20). `leptris_unicode_to_upper`/`to_lower` were also
+  case folding in disguise (`UTF8PROC_CASEFOLD` produces neither upper nor lower) — rewritten as
+  true case mapping, with `leptris_unicode_casecmp` keeping its genuine fold semantics
+  explicitly. Builds without utf8proc keep the ASCII fallback (leptris#1182, leptris#1460).
+
+### Added
+
+- QT3 string-case corpus family adopted (leptris#1182, corpus growth resumed): fn/upper-case
+  (23/30), fn/lower-case (23/28), fn/codepoint-equal (24/37). The runner's corpus counts now
+  branch on the utf8proc capability — without it the two Unicode-mapping cases are excluded by
+  name rather than counted down.
+
+
+
 ## [1.9.280] - 2026-09-30
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/leptris/unicode/unicode.c

@@ -108,25 +108,40 @@ char* leptris_unicode_normalize(const char* str, size_t len,
 /**
  * Convert UTF-8 string to uppercase
  */
+/* Unicode CASE MAPPING (F&O upper-case/lower-case): per-codepoint
+ * utf8proc_toupper/tolower — NOT case folding. The previous
+ * UTF8PROC_CASEFOLD map folded to the canonical (lowercase-shaped)
+ * fold form, which is neither operation and left fn:upper-case
+ * wrong for every non-ASCII input (fn-upper-case-20: U+01CB must
+ * map to U+01CA). Case mapping is codepoint-wise in utf8proc's
+ * property API; encode the mapped sequence back to UTF-8. The
+ * mapped form of a BMP codepoint is <= 3 bytes, so a 4-byte worst
+ * case per input byte is a safe bound (surrogates never appear in
+ * valid UTF-8). */
 char* leptris_unicode_to_upper(const char* str, size_t len, size_t* out_len) {
     if (!str || !out_len) {
         return NULL;
     }
 
-    utf8proc_uint8_t* result = NULL;
-    utf8proc_ssize_t result_len = utf8proc_map(
-        (const utf8proc_uint8_t*)str,
-        (utf8proc_ssize_t)len,
-        &result,
-        UTF8PROC_STABLE | UTF8PROC_CASEFOLD | UTF8PROC_COMPOSE
-    );
-
-    if (result_len < 0) {
-        return NULL;
+    char* out = (char*)malloc(len * 4 + 1);
+    if (!out) return NULL;
+    size_t w = 0;
+    for (size_t i = 0; i < len; ) {
+        utf8proc_int32_t cp;
+        utf8proc_ssize_t used = utf8proc_iterate(
+            (const utf8proc_uint8_t*)str + i,
+            (utf8proc_ssize_t)(len - i), &cp);
+        if (used < 1) { free(out); return NULL; }
+        cp = utf8proc_toupper(cp);
+        utf8proc_ssize_t written = utf8proc_encode_char(
+            cp, (utf8proc_uint8_t*)out + w);
+        if (written < 1) { free(out); return NULL; }
+        w += (size_t)written;
+        i += (size_t)used;
     }
-
-    *out_len = (size_t)result_len;
-    return (char*)result;
+    out[w] = 0;
+    *out_len = w;
+    return out;
 }
 
 /**
@@ -137,20 +152,25 @@ char* leptris_unicode_to_lower(const char* str, size_t len, size_t* out_len) {
         return NULL;
     }
 
-    utf8proc_uint8_t* result = NULL;
-    utf8proc_ssize_t result_len = utf8proc_map(
-        (const utf8proc_uint8_t*)str,
-        (utf8proc_ssize_t)len,
-        &result,
-        UTF8PROC_STABLE | UTF8PROC_CASEFOLD | UTF8PROC_COMPOSE
-    );
-
-    if (result_len < 0) {
-        return NULL;
+    char* out = (char*)malloc(len * 4 + 1);
+    if (!out) return NULL;
+    size_t w = 0;
+    for (size_t i = 0; i < len; ) {
+        utf8proc_int32_t cp;
+        utf8proc_ssize_t used = utf8proc_iterate(
+            (const utf8proc_uint8_t*)str + i,
+            (utf8proc_ssize_t)(len - i), &cp);
+        if (used < 1) { free(out); return NULL; }
+        cp = utf8proc_tolower(cp);
+        utf8proc_ssize_t written = utf8proc_encode_char(
+            cp, (utf8proc_uint8_t*)out + w);
+        if (written < 1) { free(out); return NULL; }
+        w += (size_t)written;
+        i += (size_t)used;
     }
-
-    *out_len = (size_t)result_len;
-    return (char*)result;
+    out[w] = 0;
+    *out_len = w;
+    return out;
 }
 
 /**
@@ -162,10 +182,25 @@ int leptris_unicode_casecmp(const char* str1, size_t len1,
         return (str1 == str2) ? 0 : (str1 ? 1 : -1);
     }
 
-    /* Normalize both strings to lowercase for comparison */
+    /* Fold both strings for comparison — case folding, NOT
+     * lower-case mapping: the fold form is the canonical
+     * case-insensitive identity (the old to_lower did this
+     * implicitly; true case mapping is not a substitute). */
     size_t norm1_len, norm2_len;
-    char* norm1 = leptris_unicode_to_lower(str1, len1, &norm1_len);
-    char* norm2 = leptris_unicode_to_lower(str2, len2, &norm2_len);
+    utf8proc_uint8_t *f1 = NULL, *f2 = NULL;
+    utf8proc_ssize_t n1 = utf8proc_map(
+        (const utf8proc_uint8_t*)str1, (utf8proc_ssize_t)len1, &f1,
+        UTF8PROC_STABLE | UTF8PROC_CASEFOLD | UTF8PROC_COMPOSE);
+    utf8proc_ssize_t n2 = utf8proc_map(
+        (const utf8proc_uint8_t*)str2, (utf8proc_ssize_t)len2, &f2,
+        UTF8PROC_STABLE | UTF8PROC_CASEFOLD | UTF8PROC_COMPOSE);
+    if (n1 < 0 || n2 < 0) {
+        free(f1); free(f2);
+        return (str1 == str2) ? 0 : 1;
+    }
+    char* norm1 = (char*)f1;
+    char* norm2 = (char*)f2;
+    (void)0;
 
     if (!norm1 || !norm2) {
         free(norm1);

data/vendor-src/libleptris/src/leptris/xpath/functions.c

@@ -15,6 +15,7 @@
 #include "../dom/cdata.h"
 #include "../dom/comment.h"
 #include "../common/port.h"
+#include "../unicode/unicode.h"
 #include "../dtd/model.h"   /* ttdtd_lookup_attribute (id() §4.1) */
 #include <string.h>
 #include <stdlib.h>
@@ -2708,14 +2709,24 @@ static struct leptris_xpath_result* xpath_func_upper_case(
     char* src = result_to_string(arg);
     xpath_result_free(arg);
     if (!src) return NULL;
+    /* Unicode case mapping (F&O §7.4.7); ASCII fallback when
+     * utf8proc is compiled out (the cargo legs build without it —
+     * unicode.c is excluded there, so the helper must not be
+     * referenced unguarded). */
     size_t n = strlen(src);
-    char* out = LEPTRIS_ALLOC_N(char, n + 1);
-    if (!out) { LEPTRIS_FREE(src); return NULL; }
-    for (size_t i = 0; i < n; i++) {
-        unsigned char c = (unsigned char)src[i];
-        out[i] = (char)((c >= 'a' && c <= 'z') ? c - 32 : c);
+    char* out = NULL;
+#ifdef LEPTRIS_HAS_UTF8PROC
+    out = leptris_unicode_to_upper(src, n, &n);
+#endif
+    if (!out) {
+        out = LEPTRIS_ALLOC_N(char, n + 1);
+        if (!out) { LEPTRIS_FREE(src); return NULL; }
+        for (size_t i = 0; i < n; i++) {
+            unsigned char c = (unsigned char)src[i];
+            out[i] = (char)((c >= 'a' && c <= 'z') ? c - 32 : c);
+        }
+        out[n] = 0;
     }
-    out[n] = 0;
     LEPTRIS_FREE(src);
     struct leptris_xpath_result* result =
         xpath_result_new(XPATH_RESULT_STRING);
@@ -2734,13 +2745,19 @@ static struct leptris_xpath_result* xpath_func_lower_case(
     xpath_result_free(arg);
     if (!src) return NULL;
     size_t n = strlen(src);
-    char* out = LEPTRIS_ALLOC_N(char, n + 1);
-    if (!out) { LEPTRIS_FREE(src); return NULL; }
-    for (size_t i = 0; i < n; i++) {
-        unsigned char c = (unsigned char)src[i];
-        out[i] = (char)((c >= 'A' && c <= 'Z') ? c + 32 : c);
+    char* out = NULL;
+#ifdef LEPTRIS_HAS_UTF8PROC
+    out = leptris_unicode_to_lower(src, n, &n);
+#endif
+    if (!out) {
+        out = LEPTRIS_ALLOC_N(char, n + 1);
+        if (!out) { LEPTRIS_FREE(src); return NULL; }
+        for (size_t i = 0; i < n; i++) {
+            unsigned char c = (unsigned char)src[i];
+            out[i] = (char)((c >= 'A' && c <= 'Z') ? c + 32 : c);
+        }
+        out[n] = 0;
     }
-    out[n] = 0;
     LEPTRIS_FREE(src);
     struct leptris_xpath_result* result =
         xpath_result_new(XPATH_RESULT_STRING);

data/vendor-src/libleptris/test/CMakeLists.txt

@@ -87,6 +87,13 @@ leptris_add_test(test_sch_corpus  sch/test_schematron_corpus.cpp)
 leptris_add_test(test_qt3          xquery/test_qt3.cpp)
 target_compile_definitions(test_qt3 PRIVATE
     LEPTRIS_QT3_DIR="${CMAKE_CURRENT_SOURCE_DIR}/xquery/qt3")
+# leptris_static aggregates leptris_objects as SOURCES, so the
+# objects' INTERFACE compile definition does not flow through to
+# test consumers — mirror the capability flag the runner's corpus
+# counts branch on.
+if(LEPTRIS_ENABLE_UTF8PROC)
+    target_compile_definitions(test_qt3 PRIVATE LEPTRIS_HAS_UTF8PROC=1)
+endif()
 target_compile_definitions(test_sch_corpus PRIVATE
     LEPTRIS_SCH_CASES_DIR="${CMAKE_CURRENT_SOURCE_DIR}/sch/conformance-cases")
 leptris_add_test(test_parser     parser/test_parser.cpp)