leptris 1.9.239.0-arm-linux → 1.9.241.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae72b73cfc6eccb8587d96f1e5dcdd8569ed8d200d72565f2f7d8dfba2af6228
-  data.tar.gz: 9c6baf3802487f425d102a0b59245961ba56ebb1b7f868e2a1980408c74cadad
+  metadata.gz: '09c7baab41feaab758bab6e051d91ee5acb7c5bd7ee58e37eb600b43d1d694b7'
+  data.tar.gz: 900ff32369b36ae5dfdb224638ba0b8a7ba43fe82c8f438459549c1c696dbc3f
 SHA512:
-  metadata.gz: 01a8bf995021c0d835b2e5e24aa41b5b0b74555a31888c8b7fa653276ab5f8d4df92f60f0470420d7dd4d216ae04f86358fa686a105da6d1c57ee6ffadbe6e94
-  data.tar.gz: 8694064341fce7015d3fc2e4062485d805623bfd11d393e705715af3337f76cf7e647f9c964e13c567c6b3c793342295fbd8e3169073765f409640ef9ccedcd4
+  metadata.gz: 3dbb2c4e5396edf8c9af37513ade0aaa9df1f432bea1c377547061e97ed015ca2a9700e6ccceab08be413106c4f0f63e1bdf8baf773b1c89726b59103ea20bc9
+  data.tar.gz: 6b7cf40b514d7be1ed24788e04bec8557b251d08e32baf177a8b237299538b6a2aaa8469bf08033d506ee07c65fd2ca0443527c28c97db8244ababe4d5565d88

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.241.0] - 2026-09-25
+
+### Fixed
+
+- Vendored libleptris 1.9.241 (riding 1.9.240 + 1.9.241):
+  - The interleaved parse lane now applies the same §2.11 EOL
+    normalization as the classic lane (#1357) — both lanes
+    spec-identical; the lane stays env-gated off by default.
+  - xquery: order by — only a genuinely empty-sequence key takes
+    the empty mode (an empty STRING key sorts by value);
+    fn:distinct-values compares xs:duration-family members in the
+    value space and spells survivors canonically.
+  - xquery: shortest round-trip plain spelling for numbers — the
+    15-digit plain budget collided distinct decimals
+    (1.2000000000000001 vs 1.2); the branch now discovers minimal
+    significant digits and renders fixed-point uncapped.
+- Repairs the Rakefile engine pin, left at 1.9.239 by the last
+  release's version-only bump, back in lockstep with version.rb.
+
 ## [1.9.239.0] - 2026-09-25
 
 ### Fixed

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.239"
+LIBLEPTRIS_VERSION = "1.9.241"
 # 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.239.0"
+  VERSION = "1.9.241.0"
 end

data/lib/leptris/xml/ffi.rb

@@ -232,6 +232,32 @@ module Leptris
       SAX_EVENT_END_PREFIX     = 9
       SAX_EVENT_ERROR          = 10
 
+      # LeptrisSaxRecord (sax.h, #1298): one element or text record;
+      # tree as parent/next_sib record indices, strings (off,len)
+      # views into the records buffer. 10 x uint32 + uint8.
+      class SaxRecord < ::FFI::Struct
+        layout :kind, :uint32,
+               :parent, :uint32, :next_sib, :uint32,
+               :off, :uint32, :len, :uint32,
+               :line, :uint32, :start_tag_end, :uint32,
+               :elem_end, :uint32, :attr_first, :uint32,
+               :attr_count, :uint32,
+               :self_closing, :uint8
+      end
+
+      SAX_REC_ELEMENT = 0
+      SAX_REC_TEXT    = 1
+      SAX_REC_NO_INDEX = 0xFFFFFFFF
+
+      # LeptrisSaxAttr: flat attribute table entry — qname + raw
+      # value views, value_has_ws = literal \t/\n/\r present (the
+      # CONSUMER applies 3.3.3 normalization). 4 x uint32 + uint8.
+      class SaxAttr < ::FFI::Struct
+        layout :name_off, :uint32, :name_len, :uint32,
+               :value_off, :uint32, :value_len, :uint32,
+               :value_has_ws, :uint8
+      end
+
       ITERPARSE_TOP_LEVEL      = 0
       ITERPARSE_FULL_DOCUMENT  = 1
 
@@ -1049,7 +1075,10 @@ attach_function :leptris_parse_string,
       attach_function :leptris_sax_records_data, [:pointer], :pointer
       attach_function :leptris_sax_records_attrs,
         [:pointer, :pointer], :pointer
-      attach_function :leptris_sax_records_buffer, [:pointer], UTF8_STRING
+      # :pointer, NOT UTF8_STRING — the buffer carries embedded NULs
+      # between views; a C string read would truncate at the first.
+      # Views materialize via Pointer#get_string(off, len).
+      attach_function :leptris_sax_records_buffer, [:pointer], :pointer
       attach_function :leptris_sax_records_free, [:pointer], :void
       # XSLT 1.0 engine (libleptris 1.9.1): compile once, apply many.
       # XQuery 1.0 core (libleptris 1.9.64-1.9.66): orchestration
@@ -1284,6 +1313,7 @@ attach_function :leptris_parse_string,
       LEPTRIS_ERROR_NOT_FOUND = -6
       LEPTRIS_ERROR_IO = -7
       LEPTRIS_ERROR_NOT_IMPLEMENTED = -8
+      LEPTRIS_ERROR_NOT_SUPPORTED = -9
 
       XPATH_NODESET = 0
       XPATH_BOOLEAN = 1

data/lib/leptris/xml/sax/records.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# Bulk SAX records (leptris#1298, engine leptris_sax_records_parse,
+# 1.9.223+): ONE crossing drains the whole document into a flat
+# record table — elements and text runs in document order, the tree
+# as parent/next-sibling record indices, attributes an index range
+# into a flat table, every string an (off,len) view into one
+# NUL-padded buffer. The engine mints zero per-event strings; hosts
+# materialize only what they consume (name/value String = one
+# get_string each).
+#
+# Coverage: the interleaved lane's scannable subset — elements, text,
+# attributes; well-formed entity-free documents without comments/
+# PIs/CDATA/DOCTYPE/xmlns. Outside the subset .open answers nil
+# (LEPTRIS_ERROR_NOT_SUPPORTED, zero allocation) and callers fall
+# back to the callback Recorder; correctness is bit-identical.
+#
+# Field columns materialize once per drain via
+# Pointer#read_array_of_uint32 (no Ruby object per record); the
+# self_closing flag rides a separate uint8 column because it shares
+# its struct tail with padding.
+class Leptris::XML::SAX::Records
+  KIND_ELEMENT = Leptris::XML::FFI::SAX_REC_ELEMENT
+  KIND_TEXT = Leptris::XML::FFI::SAX_REC_TEXT
+
+  REC = Leptris::XML::FFI::SaxRecord
+  ATTR = Leptris::XML::FFI::SaxAttr
+  REC_U32 = REC.size / 4
+  ATTR_U32 = ATTR.size / 4
+
+  attr_reader :count, :attr_count
+
+  # Drains xml into a table. Returns nil unless the document drained
+  # cleanly — outside the scannable subset (NOT_SUPPORTED, zero
+  # allocation) OR malformed (the callback path reports parse errors
+  # with position) — callers fall back to the callback Recorder in
+  # every nil case; correctness is bit-identical.
+  def self.open(xml)
+    xml = xml.to_s
+    out = ::FFI::MemoryPointer.new(:pointer)
+    status = Leptris::XML::FFI.leptris_sax_records_parse(
+      xml, xml.bytesize, 0, out
+    )
+    return nil unless status == Leptris::XML::FFI::LEPTRIS_OK
+
+    new(out.read_pointer)
+  end
+
+  # Block form: the table dies at the end of the block — every view
+  # dies with it, so materialize inside.
+  def self.parse(xml)
+    table = open(xml)
+    return nil unless table
+
+    begin
+      yield table
+    ensure
+      table.free
+    end
+  end
+
+  def initialize(ptr)
+    @ptr = ptr
+    @count = Leptris::XML::FFI.leptris_sax_records_count(@ptr)
+    recs = Leptris::XML::FFI.leptris_sax_records_data(@ptr)
+    attr_out = ::FFI::MemoryPointer.new(:pointer)
+    attrs = Leptris::XML::FFI.leptris_sax_records_attrs(@ptr, attr_out)
+    @attr_count = attr_out.read_uint64
+    @buf = Leptris::XML::FFI.leptris_sax_records_buffer(@ptr)
+    # Whole-table single reads: no Ruby object per record. The u32
+    # columns stride by struct size; the flags (self_closing /
+    # value_has_ws) are u8 tails read per-byte off their layout
+    # offset — endian-safe.
+    @rec_u32 = recs.read_array_of_uint32(@count * REC_U32)
+    @rec_flag = recs.read_array_of_uint8(@count * REC.size)
+    @attr_u32 = attrs.read_array_of_uint32(@attr_count * ATTR_U32)
+    @attr_flag = attrs.read_array_of_uint8(@attr_count * ATTR.size)
+    @rec_flag_off = REC.offset_of(:self_closing)
+    @attr_flag_off = ATTR.offset_of(:value_has_ws)
+  end
+
+  def free
+    return if @ptr.nil?
+
+    Leptris::XML::FFI.leptris_sax_records_free(@ptr)
+    @ptr = nil
+  end
+
+  def kind(i)
+    @rec_u32[i * REC_U32]
+  end
+
+  # Parent record index (0xFFFFFFFF for document-level records).
+  def parent(i)
+    @rec_u32[i * REC_U32 + 1]
+  end
+
+  # Element name or text content — ONE String per call, UTF-8.
+  def view(i)
+    base = i * REC_U32
+    @buf.get_string(@rec_u32[base + 3], @rec_u32[base + 4])
+        .force_encoding(Encoding::UTF_8)
+  end
+
+  def self_closing?(i)
+    @rec_flag[i * REC.size + @rec_flag_off] != 0
+  end
+
+  def attr_first(i)
+    @rec_u32[i * REC_U32 + 8]
+  end
+
+  def attr_count_of(i)
+    @rec_u32[i * REC_U32 + 9]
+  end
+
+  def attr_name(k)
+    @buf.get_string(@attr_u32[k * ATTR_U32],
+                    @attr_u32[k * ATTR_U32 + 1])
+        .force_encoding(Encoding::UTF_8)
+  end
+
+  def attr_value(k)
+    @buf.get_string(@attr_u32[k * ATTR_U32 + 2],
+                    @attr_u32[k * ATTR_U32 + 3])
+        .force_encoding(Encoding::UTF_8)
+  end
+
+  # Literal \t/\n/\r in the raw value — the consumer applies
+  # XML 1.0 §3.3.3 (map each break byte to a space).
+  def attr_value_has_ws?(k)
+    @attr_flag[k * ATTR.size + @attr_flag_off] != 0
+  end
+end

data/lib/leptris/xml/sax.rb

@@ -9,6 +9,7 @@ module Leptris
       autoload :Parser, "leptris/xml/sax/parser"
       autoload :Recorder, "leptris/xml/sax/recorder"
       autoload :DomDispatch, "leptris/xml/sax/dom_dispatch"
+      autoload :Records, "leptris/xml/sax/records"
     end
   end
 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.239
+- libleptris v1.9.241
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## [Unreleased]
 
+## [1.9.241] - 2026-09-25
+
+### Fixed
+
+- xquery: shortest round-trip plain spelling for XQuery numbers.
+  The plain branch kept a 15-digit budget, so `1.2000000000000001`
+  and `1.2` collided into one spelling and fn:distinct-values
+  deduped distinct xs:decimals. The branch now discovers the minimal
+  significant digits via the same e-form loop (float-aware) and
+  renders fixed-point with `decimals = prec - exp10` — uncapped, or
+  tiny plain-range values (`1e-18`) truncate to "0".
+- QT3 corpus: distinct-values 93→94 adopted; pins-off reds 67→59.
+
+
+
+## [1.9.240] - 2026-09-25
+
+### Fixed
+
+- order-by empty-string keys, duration-typed distinct-values (xquery)
+- qualifier casts in the plan free path (descriptor)
+- §2.11 EOL normalization in the interleaved lane (#326) (dom)
+
+
+
 ## [1.9.239] - 2026-09-24
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -244,7 +244,7 @@ static void dp_plan_free(LeptrisPlan p) {
     for (uint32_t i = 0; i < p->plan_count; i++) {
         dp_plan* d = &p->plans[i];
         for (uint32_t a = 0; a < d->attribute_count; a++) {
-            free(d->attribute_plans[a].wire_name);
+            free((char *)d->attribute_plans[a].wire_name);
             for (uint16_t pi = 0;
                  pi < d->attribute_plans[a].predicate_count; pi++) {
                 free((char*)d->attribute_plans[a]
@@ -255,7 +255,7 @@ static void dp_plan_free(LeptrisPlan p) {
             free((leptris_attr_predicate*)d->attribute_plans[a].predicates);
         }
         for (uint32_t c = 0; c < d->child_count; c++) {
-            free(d->child_plans[c].wire_name);
+            free((char *)d->child_plans[c].wire_name);
             for (uint16_t pi = 0;
                  pi < d->child_plans[c].predicate_count; pi++) {
                 free((char*)d->child_plans[c]

data/vendor-src/libleptris/src/leptris/flat/direct_parse.c

@@ -2560,12 +2560,22 @@ static struct leptris_document* dp_il_build(
                             pool, a->val_len + 1);
                         if (!norm) { free(smap); free(rdepth);
                                      free(lc); goto oom_pool; }
+                        /* §2.11 (#326): CRLF is ONE line break — one
+                         * space, same collapse as the classic lane. */
+                        size_t nw = 0;
                         for (uint32_t w = 0; w < a->val_len; w++) {
                             char ch = scratch[a->val_off + w];
-                            norm[w] = (ch == '\t' || ch == '\n' ||
-                                       ch == '\r') ? ' ' : ch;
+                            if (ch == '\r') {
+                                norm[nw++] = ' ';
+                                if (w + 1 < a->val_len &&
+                                    scratch[a->val_off + w + 1] == '\n')
+                                    w++;
+                            } else {
+                                norm[nw++] = (ch == '\t' || ch == '\n')
+                                                 ? ' ' : ch;
+                            }
                         }
-                        norm[a->val_len] = '\0';
+                        norm[nw] = '\0';
                         leptris_attr_value_set_heap(
                             at, leptris_sv_from_cstr(norm));
                     } else {
@@ -2672,12 +2682,37 @@ static struct leptris_document* dp_il_build(
         } else {
             LeptrisTextNode* tn = &tblk[ntext++];
             const char* content = scratch + r->off;
+            size_t content_len = r->len;
             scratch[r->off + r->len] = '\0';
+            /* §2.11 (#326), interleaved lane: same pre-expansion
+             * CRLF/CR -> LF normalization as the classic lane;
+             * CR-free runs stay in scratch. */
+            if (memchr(content, '\r', content_len)) {
+                char* norm =
+                    (char*)leptris_pool_alloc(pool, content_len + 1);
+                if (!norm) { free(smap); free(rdepth);
+                             free(lc); goto oom_pool; }
+                char* w = norm;
+                const char* rr = content;
+                const char* r_end = content + content_len;
+                while (rr < r_end) {
+                    if (*rr == '\r') {
+                        *w++ = '\n';
+                        if (rr + 1 < r_end && rr[1] == '\n') rr++;
+                    } else {
+                        *w++ = *rr;
+                    }
+                    rr++;
+                }
+                *w = '\0';
+                content = norm;
+                content_len = (size_t)(w - norm);
+            }
             tn->base.type = LEPTRIS_NODE_TYPE_TEXT;
             tn->base.frozen = 1;
             tn->base.line = r->line;
             leptris_textnode_set_content_ptr_doc(tn, content, doc);
-            tn->content_len = r->len;
+            tn->content_len = (uint32_t)content_len;
             /* (slice 4: pool/borrowed fields gone; the il scratch
              * run is already NUL-terminated at carve) */
             tn->parent_off = 0;

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

@@ -136,17 +136,32 @@ char* xpath_number_to_string_xq_typed(double number, int float_prec) {
         snprintf(work, sizeof(work), "%sE%s", mant, exp);
         return leptris_strdup(work);
     } else {
-        /* Fraction budget: integer digits first, the fraction spends
-         * the remaining significant digits (33 places floor for the
-         * 1e-18 tail). */
-        int integer_place = (int)floor(log10(absolute_value));
-        int fraction_place = integer_place > 0
-                                 ? 15 - integer_place - 1
-                                 : 15 - integer_place;
-        if (fraction_place > 33) fraction_place = 33;
-        if (fraction_place < 0) fraction_place = 0;
-        size = (int)snprintf(work, sizeof(work), "%0.*f",
-                             fraction_place, number);
+        /* Shortest round-trip PLAIN spelling: discover the minimal
+         * significant-digit count via the e-form (float-aware like
+         * the scientific branch), then render fixed-point. The old
+         * 15-digit budget truncated the 17th digit, colliding
+         * distinct xs:decimals ("1.2" vs "1.2000000000000002")
+         * into one spelling. */
+        char mant[64];
+        int prec;
+        for (prec = 1; prec <= 17; prec++) {
+            snprintf(mant, sizeof(mant), "%.*e", prec, number);
+            double back = strtod(mant, NULL);
+            if (float_prec) back = (double)((float)back);
+            if (back == number) break;
+        }
+        int exp10 = 0;
+        char* e = strchr(mant, 'e');
+        if (e) exp10 = atoi(e + 1);
+        /* %.*e prints `prec` digits AFTER the mantissa point, so
+         * fixed-point decimals = prec - exp10 ("2.5e+00" -> 1). */
+        int decimals = prec - exp10;
+        if (decimals < 0) decimals = 0;
+        /* tiny plain-range values (1e-18) need exp10 digits of
+         * fraction — no 17 cap here or they truncate to "0" */
+        if (decimals > 40) decimals = 40;
+        size = (int)snprintf(work, sizeof(work), "%.*f",
+                             decimals, number);
     }
 
     char* start = work;

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

@@ -485,6 +485,79 @@ static struct leptris_xpath_result* fn_index_of(XPathContext* ctx,
     return out;
 }
 
+/* ISO-8601 duration value space: (months, seconds). Returns 1 when
+ * s is a duration lexical form. */
+static int dur_ms_parse(const char* s, double* out_m, double* out_s) {
+    const char* p = s;
+    int neg = (*p == '-');
+    if (neg) p++;
+    if (*p != 'P') return 0;
+    p++;
+    double m = 0, sec = 0;
+    int in_time = 0, any = 0;
+    while (*p) {
+        if (*p == 'T') {
+            in_time = 1;
+            p++;
+            any = 0;
+            continue;
+        }
+        if (!isdigit((unsigned char)*p) && *p != '.') return 0;
+        double v = strtod(p, (char**)&p);
+        char d = *p;
+        if (!d) return 0;
+        p++;
+        double sign = neg ? -1.0 : 1.0;
+        if (!in_time) {
+            if (d == 'Y') { m += sign * v * 12; any = 1; }
+            else if (d == 'M') { m += sign * v; any = 1; }
+            else if (d == 'D') { sec += sign * v * 86400; any = 1; }
+            else return 0;
+        } else {
+            if (d == 'H') { sec += sign * v * 3600; any = 1; }
+            else if (d == 'M') { sec += sign * v * 60; any = 1; }
+            else if (d == 'S') { sec += sign * v; any = 1; }
+            else return 0;
+        }
+    }
+    if (!any) return 0;
+    *out_m = m;
+    *out_s = sec;
+    return 1;
+}
+
+/* XSD canonical duration spelling: whole-value sign, no zero
+ * components, all-zero -> "PT0S". */
+static char* dur_canonical(const char* s) {
+    double m, sec;
+    if (!dur_ms_parse(s, &m, &sec)) return NULL;
+    int neg = (m < 0 || sec < 0);
+    double am = fabs(m), as = fabs(sec);
+    long long years = (long long)(am / 12);
+    long long months = (long long)am - years * 12;
+    long long days = (long long)(as / 86400);
+    double rem = as - days * 86400;
+    long long hours = (long long)(rem / 3600);
+    rem -= hours * 3600;
+    long long mins = (long long)(rem / 60);
+    double secs = rem - mins * 60;
+    if (secs > 0 && secs == (double)(long long)secs)
+        secs = (double)(long long)secs;
+    char buf[96];
+    int w = snprintf(buf, sizeof(buf), "%sP", neg ? "-" : "");
+    if (years) w += snprintf(buf + w, sizeof(buf) - w, "%lldY", years);
+    if (months) w += snprintf(buf + w, sizeof(buf) - w, "%lldM", months);
+    if (days) w += snprintf(buf + w, sizeof(buf) - w, "%lldD", days);
+    if (hours || mins || secs || (!years && !months && !days)) {
+        w += snprintf(buf + w, sizeof(buf) - w, "T");
+        if (hours) w += snprintf(buf + w, sizeof(buf) - w, "%lldH", hours);
+        if (mins) w += snprintf(buf + w, sizeof(buf) - w, "%lldM", mins);
+        if (secs || (!hours && !mins))
+            w += snprintf(buf + w, sizeof(buf) - w, "%.12gS", secs);
+    }
+    return leptris_strdup(buf);
+}
+
 static struct leptris_xpath_result* fn_distinct_values(XPathContext* ctx,
         XPathASTNode** args, size_t n) {
     size_t cnt;
@@ -501,11 +574,28 @@ static struct leptris_xpath_result* fn_distinct_values(XPathContext* ctx,
     if (out)
         for (size_t k = 0; k < cnt; k++) {
             int dup = 0;
-            for (size_t j = 0; j < k && !dup; j++)
-                if (atom_seq_eq_n(items[k], items[j], 1)) dup = 1;
-            /* first occurrence keeps its original spelling
-             * (distinct-values((1, 2.0, 3, 2)) = 1, 2.0, 3) */
-            if (!dup) seq_push_str(out, items[k]);
+            double mk = 0, sk = 0;
+            int dk = dur_ms_parse(items[k], &mk, &sk);
+            for (size_t j = 0; j < k && !dup; j++) {
+                if (dk) {
+                    /* xs:duration eq compares the value space
+                     * (months, seconds) across the duration
+                     * subtypes (cbcl-distinct-values-013) */
+                    double mj = 0, sj = 0;
+                    if (dur_ms_parse(items[j], &mj, &sj) &&
+                        mj == mk && sj == sk)
+                        dup = 1;
+                } else if (atom_seq_eq_n(items[k], items[j], 1)) {
+                    dup = 1;
+                }
+            }
+            if (!dup) {
+                /* duration survivors spell canonically
+                 * (dayTimeDuration P0D -> "PT0S") */
+                char* push = dk ? dur_canonical(items[k]) : NULL;
+                seq_push_str(out, push ? push : items[k]);
+                free(push);
+            }
         }
     free_items(items, cnt);
     return out;

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

@@ -2898,13 +2898,26 @@ static LeptrisXPathResult xq_eval_impl(
                         for (size_t k = 0; k < q->nkeys; k++) {
                             struct leptris_xpath_result* r =
                                 evaluate_expr(ctx, q->keys[k].key);
-                            char* ks = r ? xpath_to_string(r) : NULL;
+                            /* Only a genuinely EMPTY SEQUENCE key
+                             * takes the empty-mode; an empty STRING
+                             * key is a real key and sorts by value
+                             * ("" < "a" — cbcl-distinct-values-010).
+                             * NULL slot = empty sequence. */
+                            int empty_seq =
+                                !r || (r->type == XPATH_RESULT_NODESET &&
+                                       (!r->value.nodeset_value ||
+                                        r->value.nodeset_value->count ==
+                                            0));
+                            char* ks =
+                                empty_seq ? NULL
+                                          : (r ? xpath_to_string(r)
+                                               : NULL);
                             if (ti == 0)
                                 q->keys[k].strmode =
                                     (r &&
                                      r->type == XPATH_RESULT_STRING);
                             xpath_result_free(r);
-                            tuples[ti].keys[k] = ks ? ks : strdup("");
+                            tuples[ti].keys[k] = ks;
                         }
                     }
                 }
@@ -2936,8 +2949,8 @@ static LeptrisXPathResult xq_eval_impl(
                             const char* ka = tuples[j - 1].keys[k];
                             const char* kb = tmp.keys[k];
                             int c;
-                            int ea = !ka || !ka[0];
-                            int eb = !kb || !kb[0];
+                            int ea = !ka;
+                            int eb = !kb;
                             if (ea || eb) {
                                 /* empty-sequence keys order by the
                                  * key's empty mode (greatest default) */

data/vendor-src/libleptris/test/xquery/test_qt3.cpp

@@ -892,9 +892,8 @@ TEST(Qt3Subset, FnStringJoin) {
 TEST(Qt3Subset, FnIndexOf) {
     /* Reds are the typed-atom class: NaN/INF members and
      * xs:date/dateTime compare via the string channel. */
-    run_test_set("fn/index-of.xml", {}, 42, {},
+    run_test_set("fn/index-of.xml", {}, 43, {},
                  {
-                   "K-SeqIndexOfFunc-17",
                    "fn-indexof-mix-args-013",
 
                  });
@@ -914,7 +913,7 @@ TEST(Qt3Subset, FnRemove) {
     /* Reds: instance-of on typed sequences + the typed-member class. */
     run_test_set("fn/remove.xml", {}, 23, {},
                  {
-                   "K-SeqRemoveFunc-8",
+                   "fn-remove-mix-args-010", /* float member in a mixed pair loses float-aware spelling */
                    "fn-remove-mix-args-017",
 
                  });
@@ -933,10 +932,9 @@ TEST(Qt3Subset, FnReverse) {
 TEST(Qt3Subset, FnSubsequence) {
     /* Reds: typed members under assert-xml (float/boolean/dateTime
      * spellings) + start/length NaN rules. */
-    run_test_set("fn/subsequence.xml", {}, 61, {},
+    run_test_set("fn/subsequence.xml", {}, 65, {},
                  {
                    "K-SeqSubsequenceFunc-34",
-                   "cbcl-subsequence-001",
                    "cbcl-subsequence-003",
                    "cbcl-subsequence-005",
                    "cbcl-subsequence-011",
@@ -945,9 +943,6 @@ TEST(Qt3Subset, FnSubsequence) {
                    "cbcl-subsequence-014",
                    "cbcl-subsequence-019",
                    "cbcl-subsequence-025",
-                   "cbcl-subsequence-026",
-                   "fn-subsequence-mix-args-011",
-                   "fn-subsequence-mix-args-016",
                    "fn-subsequence-mix-args-025",
 
                  });
@@ -959,19 +954,14 @@ TEST(Qt3Subset, FnDistinctValues) {
     /* mixed-args-012 (decimal-vs-float dedup) diverges ONLY inside
      * the LTO'd test binary — identical query passes standalone and
      * via the public API; CI's non-LTO/gcc legs are the arbiter. */
-    run_test_set("fn/distinct-values.xml", {}, 89, {},
+    run_test_set("fn/distinct-values.xml", {}, 94, {},
                  {
                    "cbcl-distinct-values-002",
                    "cbcl-distinct-values-002b",
                    "cbcl-distinct-values-007",
-                   "cbcl-distinct-values-010",
-                   "cbcl-distinct-values-011",
-                   "cbcl-distinct-values-013",
-                   "cbcl-distinct-values-016",
                    "fn-distinct-values-1",
                    "fn-distinct-values-2",
                    "fn-distinct-values-mixed-args-010",
-                   "fn-distinct-values-mixed-args-012",
                    "fn-distinct-values-mixed-args-018",
 
                  });
@@ -981,7 +971,7 @@ TEST(Qt3Subset, FnDeepEqual) {
     /* Reds: type-aware atomic equality (xs:float ne xs:double,
      * xs:date ne string, NaN = NaN inside typed wrappers) — needs
      * the typed-atom model. */
-    run_test_set("fn/deep-equal.xml", {}, 192, {},
+    run_test_set("fn/deep-equal.xml", {}, 193, {},
                  {
                    "K2-SeqDeepEqualFunc-14",
                    "K2-SeqDeepEqualFunc-15",
@@ -1002,7 +992,6 @@ TEST(Qt3Subset, FnDeepEqual) {
                    "cbcl-deep-equal-002",
                    "cbcl-deep-equal-003",
                    "cbcl-deep-equal-004",
-                   "cbcl-deep-equal-010",
                    "fn-deep-equal-arrays-1",
                    "fn-deep-equal-arrays-14",
                    "fn-deep-equal-arrays-15",

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.239",
+  "version": "1.9.241",
   "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.239.0
+  version: 1.9.241.0
 platform: arm-linux
 authors:
 - Ribose Inc.
@@ -177,6 +177,7 @@ files:
 - lib/leptris/xml/sax/dom_dispatch.rb
 - lib/leptris/xml/sax/parser.rb
 - lib/leptris/xml/sax/recorder.rb
+- lib/leptris/xml/sax/records.rb
 - lib/leptris/xml/schematron.rb
 - lib/leptris/xml/searchable.rb
 - lib/leptris/xml/serialization.rb