leptris 1.9.323.0 → 1.9.324.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d10f6b3b909939e8ac8b34a658edc1dbcfda8e2fe00b2718a6a173e4f8edb7a
-  data.tar.gz: 4f029c7a9e91e1f9fd894a73b4f0bf27e1508edf7bde95ccf54a659bde63a646
+  metadata.gz: 20ca01027af6d2d9c7dd54b359eb38fb8243682d85499c82fa021f22605718f6
+  data.tar.gz: 67293f668204144634cac5a732f48376f218ac225378f1139809900ccd459c06
 SHA512:
-  metadata.gz: 4d47a9c1683ebbd4d3e5e014e1287d1d0d5b32e75da0eea029ada1692b0d13daf7a2394a5fca647947127118035c93cadc88b317bded1da7138fb54d51f78100
-  data.tar.gz: 773ceaf67ef802ba7202952f7a2a39368b9572c2ca6888d94e386ba191735afc2963cc94722cc730a9f3fd366724e54ecf51084c0a8665d27cdd3451ec073e0e
+  metadata.gz: 8a6421039f5259c8887348842d639ab31c270fb628b22538b51d5426093aee61dce662de3a5c1386a00faa8fbd6cc2ddc715fe856c14ed3dc0e073c369491858
+  data.tar.gz: 17a7df64ddb31b03471b14fcbe99c15ced17574da99709fa316de42b8176b62c8cc6b6722f6c8d6f3529981e6b53b4e7b28ec1474046bd33fb2dceebe33ca8f7

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.323"
+LIBLEPTRIS_VERSION = "1.9.324"
 # 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.323.0"
+  VERSION = "1.9.324.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.323
+- libleptris v1.9.324
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## [Unreleased]
 
+## [1.9.324] - 2026-10-08
+
+### Added
+
+- **XSD identity constraints — tier-1 scope complete (#1075,
+  PR #1598).** `xs:key` / `xs:unique` / `xs:keyref` capture on
+  top-level element declarations (direct children or inside the
+  inline complexType) and two-pass instance validation driven by
+  the engine's own XPath with element context: pass 1 collects
+  key/unique field tuples (string-value extraction — attribute
+  fields included), enforces uniqueness, and requires non-empty
+  key fields; pass 2 collects keyref tuples; resolution then
+  requires every keyref to match a collected key/unique tuple.
+  The selector reads the `xs:selector` child's `@xpath`. Tuple
+  tables deep-copy their strings; IC captures free with the
+  schema. This completes the tier-1 engine scope: compile →
+  datatypes/facets → content models → instance validation →
+  identity constraints, gated on libxml2's 163-fixture corpus.
+
+
+
 ## [1.9.323] - 2026-10-08
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -13,6 +13,8 @@
 
 #define XSD_NS "http://www.w3.org/2001/XMLSchema"
 
+void xsd_capture_ics(struct leptris_xsd_schema* s,
+                     LeptrisElement elem, const char* element_name);
 extern int xsd_simple_valid(const XsdSimple* simple, const char* v);
 extern struct xsd_validator* xsd_validator_new(
     struct leptris_xsd_schema* s);
@@ -33,6 +35,7 @@ struct leptris_xsd_schema {
     XsdElementDecl* elements;
     XsdCm* complex_types; /* name-carrying model roots */
     XsdTypeAttrs* type_attrs;
+    XsdElementIcs* element_ics;
     char* target_ns;
     void* validator; /* slice-4 parked error list */
     char* error;
@@ -387,7 +390,10 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
                     d->next = s->elements;
                     s->elements = d;
                 }
+                xsd_capture_ics(s, (LeptrisElement)n, nm);
             } else if (nm) {
+                /* slice 6: identity constraints ride the element. */
+                xsd_capture_ics(s, (LeptrisElement)n, nm);
                 /* #1592: inline anonymous type — capture under the
                  * synthesized slot and point the declaration at it. */
                 char synth[512];
@@ -482,6 +488,24 @@ LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
     struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
     if (!s) return;
     xsd_cm_free(s->complex_types);
+    XsdElementIcs* slot = s->element_ics;
+    while (slot) {
+        XsdElementIcs* sn = slot->next;
+        XsdIc* ic = slot->constraints;
+        while (ic) {
+            XsdIc* in = ic->next;
+            free(ic->name);
+            free(ic->selector);
+            for (size_t f = 0; f < ic->field_count; f++)
+                free(ic->fields[f]);
+            free(ic->refer);
+            free(ic);
+            ic = in;
+        }
+        free(slot->element_name);
+        free(slot);
+        slot = sn;
+    }
     XsdTypeAttrs* ta = s->type_attrs;
     while (ta) {
         XsdTypeAttrs* tn = ta->next;
@@ -551,6 +575,146 @@ LEPTRIS_API int leptris_xsd_simple_valid(LeptrisXsdSchema schema,
     return xsd_valid_chain(s, t, lexical, 0);
 }
 
+/* ---- slice 6: identity-constraint capture ------------------------ */
+
+/* The xs:selector child's @xpath (a child element, not an
+ * attribute of the constraint element itself). */
+static char* xsd_ic_selector_xpath(LeptrisElement constraint) {
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(constraint));
+         n; n = leptris_node_next_sibling(n)) {
+        if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        LeptrisElement e = (LeptrisElement)n;
+        const char* local = NULL, *prefix = NULL, *uri = NULL;
+        leptris_element_expanded_name(e, &local, &prefix, &uri);
+        if (!local || !uri || strcmp(uri, XSD_NS) != 0) continue;
+        if (strcmp(local, "selector") == 0)
+            return xsd_strdup(leptris_element_attribute(e, "xpath"));
+    }
+    return NULL;
+}
+
+void xsd_capture_ics(struct leptris_xsd_schema* s,
+                     LeptrisElement elem, const char* element_name) {
+    XsdIc* head = NULL;
+    XsdIc* tail = NULL;
+    /* ICs are direct children of xs:element, or children of its
+     * inline complexType — one hop covers the second spelling. */
+    for (int hop = 0; hop < 2; hop++) {
+        for (LeptrisNodeRef n =
+                 leptris_node_first_child(leptris_element_as_node(elem));
+             n; n = leptris_node_next_sibling(n)) {
+            if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+                continue;
+            LeptrisElement e = (LeptrisElement)n;
+            const char* local = NULL, *prefix = NULL, *uri = NULL;
+            leptris_element_expanded_name(e, &local, &prefix, &uri);
+            if (!local || !uri || strcmp(uri, XSD_NS) != 0) continue;
+            if (hop == 0 &&
+                (strcmp(local, "key") == 0 ||
+                 strcmp(local, "unique") == 0 ||
+                 strcmp(local, "keyref") == 0)) {
+                XsdIc* ic = (XsdIc*)calloc(1, sizeof(*ic));
+                if (!ic) continue;
+                ic->kind = strcmp(local, "key") == 0     ? 0
+                           : strcmp(local, "unique") == 0 ? 1
+                                                          : 2;
+                ic->name = xsd_strdup(
+                    leptris_element_attribute(e, "name"));
+                ic->selector = xsd_ic_selector_xpath(e);
+                ic->refer = xsd_strdup(
+                    leptris_element_attribute(e, "refer"));
+                for (LeptrisNodeRef fc = leptris_node_first_child(
+                         leptris_element_as_node(e));
+                     fc && ic->field_count < 8;
+                     fc = leptris_node_next_sibling(fc)) {
+                    if (leptris_node_get_type(fc) !=
+                        LEPTRIS_NODE_TYPE_ELEMENT)
+                        continue;
+                    LeptrisElement fe = (LeptrisElement)fc;
+                    const char* fl = NULL, *fp = NULL, *fu = NULL;
+                    leptris_element_expanded_name(fe, &fl, &fp, &fu);
+                    if (!fl || !fu || strcmp(fu, XSD_NS) != 0) continue;
+                    if (strcmp(fl, "field") != 0) continue;
+                    ic->fields[ic->field_count++] = xsd_strdup(
+                        leptris_element_attribute(fe, "xpath"));
+                }
+                if (tail)
+                    tail->next = ic;
+                else
+                    head = ic;
+                tail = ic;
+            } else if (hop == 0 && strcmp(local, "complexType") == 0) {
+                /* descend into the inline type's ICs */
+                for (LeptrisNodeRef ic_n = leptris_node_first_child(
+                         leptris_element_as_node(e));
+                     ic_n; ic_n = leptris_node_next_sibling(ic_n)) {
+                    if (leptris_node_get_type(ic_n) !=
+                        LEPTRIS_NODE_TYPE_ELEMENT)
+                        continue;
+                    LeptrisElement ie = (LeptrisElement)ic_n;
+                    const char* il = NULL, *ip = NULL, *iu = NULL;
+                    leptris_element_expanded_name(ie, &il, &ip, &iu);
+                    if (!il || !iu || strcmp(iu, XSD_NS) != 0) continue;
+                    if (strcmp(il, "key") != 0 &&
+                        strcmp(il, "unique") != 0 &&
+                        strcmp(il, "keyref") != 0)
+                        continue;
+                    XsdIc* ic = (XsdIc*)calloc(1, sizeof(*ic));
+                    if (!ic) continue;
+                    ic->kind = strcmp(il, "key") == 0     ? 0
+                               : strcmp(il, "unique") == 0 ? 1
+                                                            : 2;
+                    ic->name = xsd_strdup(
+                        leptris_element_attribute(ie, "name"));
+                    ic->selector = xsd_ic_selector_xpath(ie);
+                    ic->refer = xsd_strdup(
+                        leptris_element_attribute(ie, "refer"));
+                    for (LeptrisNodeRef fc =
+                             leptris_node_first_child(
+                                 leptris_element_as_node(ie));
+                         fc && ic->field_count < 8;
+                         fc = leptris_node_next_sibling(fc)) {
+                        if (leptris_node_get_type(fc) !=
+                            LEPTRIS_NODE_TYPE_ELEMENT)
+                            continue;
+                        LeptrisElement fe = (LeptrisElement)fc;
+                        const char* fl = NULL, *fp = NULL, *fu = NULL;
+                        leptris_element_expanded_name(fe, &fl, &fp,
+                                                   &fu);
+                        if (!fl || !fu || strcmp(fu, XSD_NS) != 0)
+                            continue;
+                        if (strcmp(fl, "field") != 0) continue;
+                        ic->fields[ic->field_count++] = xsd_strdup(
+                            leptris_element_attribute(fe, "xpath"));
+                    }
+                    if (tail)
+                        tail->next = ic;
+                    else
+                        head = ic;
+                    tail = ic;
+                }
+            }
+        }
+    }
+    if (!head) return;
+    XsdElementIcs* slot = (XsdElementIcs*)calloc(1, sizeof(*slot));
+    if (!slot) return;
+    slot->element_name = xsd_strdup(element_name);
+    slot->constraints = head;
+    slot->next = s->element_ics;
+    s->element_ics = slot;
+}
+
+const XsdElementIcs* xsd_find_element_ics(struct leptris_xsd_schema* s,
+                                          const char* element_name) {
+    if (!s || !element_name) return NULL;
+    for (XsdElementIcs* t = s->element_ics; t; t = t->next)
+        if (strcmp(t->element_name, element_name) == 0) return t;
+    return NULL;
+}
+
 /* ---- validator accessors (validate.c) --------------------------- */
 
 const XsdElementDecl* xsd_find_element(struct leptris_xsd_schema* s,

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

@@ -40,6 +40,8 @@ extern const XsdSimple* xsd_find_simple_pub(
 extern const char* xsd_target_ns(struct leptris_xsd_schema* s);
 extern const XsdTypeAttrs* xsd_find_type_attrs(
     struct leptris_xsd_schema* s, const char* type_name);
+extern const XsdElementIcs* xsd_find_element_ics(
+    struct leptris_xsd_schema* s, const char* element_name);
 
 /* ---- error list ---------------------------------------------------- */
 
@@ -248,6 +250,206 @@ static void validate_element(struct xsd_validator* v,
     }
 }
 
+/* ---- slice 6: identity constraints -------------------------------- */
+
+/* A key tuple: the field values of one selected node. */
+typedef struct xsd_key_tuple {
+    char* values[8];
+    size_t count;
+    struct xsd_key_tuple* next;
+} XsdKeyTuple;
+
+/* All tuples collected for one constraint name, keyed by name. */
+typedef struct xsd_key_table {
+    char* name;
+    XsdKeyTuple* tuples;
+    XsdKeyTuple* tail;
+    struct xsd_key_table* next;
+} XsdKeyTable;
+
+static XsdKeyTable* table_find(XsdKeyTable* head, const char* name) {
+    for (; head; head = head->next)
+        if (strcmp(head->name, name) == 0) return head;
+    return NULL;
+}
+
+static char* xsd_dup_str(const char* s) {
+    if (!s) return NULL;
+    size_t n = strlen(s) + 1;
+    char* out = (char*)malloc(n);
+    if (out) memcpy(out, s, n);
+    return out;
+}
+
+static void table_add(XsdKeyTable** head, const char* name,
+                      char* const* values, size_t count) {
+    XsdKeyTable* t = table_find(*head, name);
+    if (!t) {
+        t = (XsdKeyTable*)calloc(1, sizeof(*t));
+        if (!t) return;
+        size_t n = strlen(name) + 1;
+        t->name = (char*)malloc(n);
+        if (!t->name) { free(t); return; }
+        memcpy(t->name, name, n);
+        t->next = *head;
+        *head = t;
+    }
+    XsdKeyTuple* tup = (XsdKeyTuple*)calloc(1, sizeof(*tup));
+    if (!tup) return;
+    for (size_t i = 0; i < count && i < 8; i++)
+        tup->values[i] = xsd_dup_str(values[i]);
+    tup->count = count < 8 ? count : 8;
+    if (t->tail)
+        t->tail->next = tup;
+    else
+        t->tuples = tup;
+    t->tail = tup;
+}
+
+/* Evaluate one IC against the scoping element. pass1: collect
+ * key/unique tuples and enforce uniqueness (key: also non-empty
+ * fields). pass2: keyref tuples resolve against collected tables. */
+static void validate_ics(struct xsd_validator* v,
+                         struct leptris_xsd_schema* s,
+                         LeptrisElement elem, const char* elem_name,
+                         XsdKeyTable** tables, int pass) {
+    (void)v;
+    const XsdElementIcs* ics = xsd_find_element_ics(s, elem_name);
+    if (!ics) return;
+    extern struct leptris_document* leptris_element_get_document(
+        LeptrisElement elem);
+    LeptrisDocument doc = leptris_element_get_document(elem);
+    for (XsdIc* ic = ics->constraints; ic; ic = ic->next) {
+        int is_ref = ic->kind == 2;
+        if (pass == 1 && is_ref) continue;
+        if (pass == 2 && !is_ref) continue;
+        if (!ic->selector || !ic->name) continue;
+        LeptrisXPathResult sel =
+            leptris_xpath_eval(doc, elem, ic->selector);
+        if (!sel) continue;
+        size_t sel_count = leptris_xpath_result_count(sel);
+        for (size_t i = 0; i < sel_count; i++) {
+            LeptrisElement node = leptris_xpath_result_get(sel, i);
+            if (!node) continue;
+            /* field values: string of each field expression */
+            char* vals[8] = {0};
+            size_t nv = 0;
+            int missing = 0;
+            for (size_t f = 0; f < ic->field_count && f < 8; f++) {
+                LeptrisXPathResult fr =
+                    leptris_xpath_eval(doc, node, ic->fields[f]);
+                if (!fr || leptris_xpath_result_count(fr) == 0) {
+                    missing = 1;
+                    if (fr) leptris_xpath_result_free(fr);
+                    break;
+                }
+                /* String-value of the first node — attribute nodes
+                 * included (leptris_xpath_result_string handles every
+                 * node kind; #3526 contract). */
+                char* sv = leptris_xpath_result_string(fr);
+                leptris_xpath_result_free(fr);
+                vals[nv] = xsd_dup_str(sv ? sv : "");
+                leptris_free_string(sv);
+                nv++;
+            }
+            for (size_t k = 0; k < nv; k++)
+                if (!vals[k] || !vals[k][0]) missing = 1;
+            if (missing) {
+                if (ic->kind == 0)
+                    verrf(v, "key", ic->name,
+                          "a selected node is missing a field value");
+                for (size_t k = 0; k < nv; k++) free(vals[k]);
+                continue;
+            }
+            if (pass == 1) {
+                /* uniqueness within this constraint */
+                XsdKeyTable* t = table_find(*tables, ic->name);
+                int dup = 0;
+                if (t) {
+                    for (XsdKeyTuple* tup = t->tuples; tup;
+                         tup = tup->next) {
+                        int eq = tup->count == nv;
+                        for (size_t k = 0; eq && k < nv; k++)
+                            if (strcmp(tup->values[k], vals[k]) != 0)
+                                eq = 0;
+                        if (eq) { dup = 1; break; }
+                    }
+                }
+                if (dup) {
+                    verrf(v, ic->kind == 0 ? "key" : "unique",
+                          ic->name, "duplicate key tuple");
+                }
+                table_add(tables, ic->name, vals, nv);
+            } else {
+                /* keyref: resolve later (deferred to pass 2 end) —
+                 * store under the REFER name */
+                table_add(tables, ic->refer ? ic->refer : "",
+                          vals, nv);
+            }
+            for (size_t k = 0; k < nv; k++) free(vals[k]);
+        }
+        leptris_xpath_result_free(sel);
+    }
+}
+
+/* Pass 2 tail: every keyref tuple must appear in the referenced
+ * key/unique table. */
+static void resolve_keyrefs(struct xsd_validator* v,
+                            struct leptris_xsd_schema* s,
+                            XsdKeyTable* all, XsdKeyTable* refs) {
+    (void)s;
+    for (XsdKeyTable* rt = refs; rt; rt = rt->next) {
+        XsdKeyTable* target = table_find(all, rt->name);
+        if (!target) continue; /* unknown refer: capture-time lax */
+        for (XsdKeyTuple* want = rt->tuples; want; want = want->next) {
+            int found = 0;
+            for (XsdKeyTuple* have = target->tuples; have;
+                 have = have->next) {
+                int eq = have->count == want->count;
+                for (size_t k = 0; eq && k < want->count; k++)
+                    if (strcmp(have->values[k], want->values[k]) != 0)
+                        eq = 0;
+                if (eq) { found = 1; break; }
+            }
+            if (!found)
+                verrf(v, "keyref", rt->name,
+                      "reference does not resolve to any key");
+        }
+    }
+}
+
+static void tables_free(XsdKeyTable* t) {
+    while (t) {
+        XsdKeyTable* n = t->next;
+        XsdKeyTuple* tup = t->tuples;
+        while (tup) {
+            XsdKeyTuple* tn = tup->next;
+            for (size_t k = 0; k < tup->count; k++) free(tup->values[k]);
+            free(tup);
+            tup = tn;
+        }
+        free(t->name);
+        free(t);
+        t = n;
+    }
+}
+
+/* Walk every element carrying constraints in both passes. */
+static void ic_walk(struct xsd_validator* v, struct leptris_xsd_schema* s,
+                    LeptrisElement elem, XsdKeyTable** keys,
+                    XsdKeyTable** refs, int pass) {
+    const char* local = NULL;
+    leptris_element_expanded_name(elem, &local, NULL, NULL);
+    if (local) validate_ics(v, s, elem, local, pass == 1 ? keys : refs, pass);
+    for (LeptrisNodeRef c =
+             leptris_node_first_child(leptris_element_as_node(elem));
+         c; c = leptris_node_next_sibling(c)) {
+        if (leptris_node_get_type(c) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        ic_walk(v, s, (LeptrisElement)c, keys, refs, pass);
+    }
+}
+
 struct xsd_validator* xsd_validator_new(struct leptris_xsd_schema* s) {
     struct xsd_validator* v =
         (struct xsd_validator*)calloc(1, sizeof(*v));
@@ -272,6 +474,17 @@ int xsd_validator_run(struct xsd_validator* v, LeptrisDocument doc) {
     LeptrisElement root = leptris_document_root(doc);
     if (!root) return -1;
     validate_element(v, v->s, root, 0);
+
+    /* slice 6: identity constraints — collect (pass 1), resolve
+     * keyrefs (pass 2). */
+    XsdKeyTable* keys = NULL;
+    XsdKeyTable* refs = NULL;
+    ic_walk(v, v->s, root, &keys, &refs, 1);
+    ic_walk(v, v->s, root, &keys, &refs, 2);
+    resolve_keyrefs(v, v->s, keys, refs);
+    tables_free(keys);
+    tables_free(refs);
+
     return v->count == 0 ? 1 : 0;
 }
 

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

@@ -76,6 +76,26 @@ typedef struct xsd_attr_decl {
 
 /* complexType name -> its attribute declarations (hash-free: a
  * parallel list keyed the same way as complex model roots). */
+/* ---- slice 6: identity constraints -------------------------------- */
+
+/* xs:key | xs:unique | xs:keyref captured on an element decl. */
+typedef struct xsd_ic {
+    char* name;    /* constraint name */
+    int kind;      /* 0 = key, 1 = unique, 2 = keyref */
+    char* selector; /* XPath relative to the scoping element */
+    char* fields[8]; /* XPaths relative to each selected node */
+    size_t field_count;
+    char* refer;   /* keyref: the referenced constraint's name */
+    struct xsd_ic* next;
+} XsdIc;
+
+/* Per-declaration constraint list: entries keyed by element name. */
+typedef struct xsd_element_ics {
+    char* element_name;
+    XsdIc* constraints;
+    struct xsd_element_ics* next;
+} XsdElementIcs;
+
 typedef struct xsd_type_attrs {
     char* type_name;
     XsdAttrDecl* attrs;

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

@@ -605,3 +605,122 @@ TEST(XsdDatatypes, AnonymousInlineSimpleTypeOnParticle) {
 }
 
 }  // namespace
+
+// ---- slice 6: identity constraints ---------------------------------
+namespace {
+
+const char* k_ic_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+    "<xs:element name=\"catalog\">"
+    "<xs:complexType>"
+    "<xs:sequence>"
+    "<xs:element name=\"product\" maxOccurs=\"unbounded\">"
+    "<xs:complexType>"
+    "<xs:sequence>"
+    "<xs:element name=\"partNum\" type=\"xs:string\"/>"
+    "</xs:sequence>"
+    "<xs:attribute name=\"id\" type=\"xs:string\" use=\"required\"/>"
+    "</xs:complexType>"
+    "</xs:element>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "<xs:key name=\"productId\">"
+    "<xs:selector xpath=\"product\"/>"
+    "<xs:field xpath=\"@id\"/>"
+    "</xs:key>"
+    "<xs:keyref name=\"productRef\" refer=\"productId\">"
+    "<xs:selector xpath=\"product\"/>"
+    "<xs:field xpath=\"partNum\"/>"
+    "</xs:keyref>"
+    "</xs:element>"
+    "</xs:schema>";
+
+TEST(XsdIc, UniqueKeysValidate) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile(k_ic_schema, strlen(k_ic_schema), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* xml =
+        "<catalog>"
+        "<product id=\"A1\"><partNum>A1</partNum></product>"
+        "<product id=\"B2\"><partNum>B2</partNum></product>"
+        "</catalog>";
+    LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
+    ASSERT_NE(d, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, d), 1)
+        << (leptris_xsd_error_count(s) ? leptris_xsd_error_at(s, 0) : "");
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+}
+
+TEST(XsdIc, DuplicateKeyReports) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile(k_ic_schema, strlen(k_ic_schema), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* xml =
+        "<catalog>"
+        "<product id=\"A1\"><partNum>A1</partNum></product>"
+        "<product id=\"A1\"><partNum>zz</partNum></product>"
+        "</catalog>";
+    LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
+    ASSERT_NE(d, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, d), 0);
+    size_t n = leptris_xsd_error_count(s);
+    int saw_dup = 0;
+    for (size_t i = 0; i < n; i++) {
+        const char* e = leptris_xsd_error_at(s, i);
+        if (e && strstr(e, "duplicate")) saw_dup = 1;
+    }
+    EXPECT_TRUE(saw_dup);
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+}
+
+TEST(XsdIc, UnresolvedKeyrefReports) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile(k_ic_schema, strlen(k_ic_schema), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* xml =
+        "<catalog>"
+        "<product id=\"A1\"><partNum>NOPE</partNum></product>"
+        "</catalog>";
+    LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
+    ASSERT_NE(d, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, d), 0);
+    size_t n = leptris_xsd_error_count(s);
+    int saw_ref = 0;
+    for (size_t i = 0; i < n; i++) {
+        const char* e = leptris_xsd_error_at(s, i);
+        if (e && strstr(e, "keyref")) saw_ref = 1;
+    }
+    EXPECT_TRUE(saw_ref);
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+}
+
+TEST(XsdIc, KeyRequiresFieldValues) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xsd =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"r\">"
+        "<xs:complexType><xs:sequence>"
+        "<xs:element name=\"item\" maxOccurs=\"unbounded\"/>"
+        "</xs:sequence></xs:complexType>"
+        "<xs:key name=\"k\">"
+        "<xs:selector xpath=\"item\"/>"
+        "<xs:field xpath=\"@id\"/>"
+        "</xs:key>"
+        "</xs:element></xs:schema>";
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* xml = "<r><item/><item id=\"a\"/></r>";
+    LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
+    ASSERT_NE(d, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, d), 0); /* missing field */
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+}
+
+}  // namespace

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.323",
+  "version": "1.9.324",
   "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.323.0
+  version: 1.9.324.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-08 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi