leptris 1.9.322.0-aarch64-linux → 1.9.324.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cff747c994e40643b0cc1a8ac9eed34824664b6e88888195ec4a2f4191dca78
-  data.tar.gz: bbd9e7ed63e8e24d383368399d0da9fc401e664b9377411ffaecb646486e70a3
+  metadata.gz: ed267566d3e55930faa65d87747fd502b922376cd3f16d6783f04ae7de3a47e6
+  data.tar.gz: 8184d0c615d800963d0cc817d3ede259727048e2dd17467bc2c8ef02766f9234
 SHA512:
-  metadata.gz: dfd0aa551baa98ecdd243f7bf8ba3d88583ebb1ae1b880fad72e9337963971cd46898550b0aea73da6c6f4299d350a04f2a92f8d835f068624a3ca234c344e65
-  data.tar.gz: 6bf7ecfe8511c5567a17643220f651fb2c560f5d8f178e1fd3af370e40f52d1bad67ad7eb102175525f9192a810872ad8a85a0f9cec0a92a8c995765e3528849
+  metadata.gz: 0b42f07f5f59d5002dd4743f179508b1518e56f85127479d584d7856535975f403db11af37b69c04cdfaa790dac9202bf16b21d84baeaff2cf2ab8fee27a1faf
+  data.tar.gz: 6b08a56371d60b846590531f510e9cd9fb86d94baa5099e9a2df302c7aade031317ab5fc58ef3ee86a7dd318d37945c66f5ba144f4b2fab5e140fc928f8f636c

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.9.323.0] - 2026-10-08
+
+### Fixed — engine sync (libleptris 1.9.323)
+
+- **Inline anonymous complexType/simpleType capture (#1592,
+  engine PR #1596)**: elements carrying an inline anonymous type —
+  the most common XSD spelling — previously got no content model
+  (instance validation silently skipped their content check;
+  content_valid? answered -1). Inline types capture under a
+  synthesized element:NAME slot now; particle text types through
+  the slot too. Pinned: content-model enforcement with enumerated
+  errors, content_valid? answering, anonymous simpleType
+  patterns binding.
+
 ## [1.9.322.0] - 2026-10-08
 
 ### Engine sync (libleptris 1.9.322)

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.322"
+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.322.0"
+  VERSION = "1.9.324.0"
 end

data/lib/leptris/xml/document.rb

@@ -533,6 +533,11 @@ class Leptris::XML::Document
       Leptris::XML::Serialization::DOCUMENT_SERIALIZE_INTO, c_ptr,
       indent: indent, no_decl: no_decl, encoding: encoding)
   end
+
+  # Nokogiri parity (leptris#1595): to_s serializes the document.
+  def to_s
+    to_xml
+  end
   alias_method :to_s, :to_xml
   alias_method :serialize, :to_xml
 

data/lib/leptris/xml/element.rb

@@ -943,6 +943,14 @@ class Leptris::XML::Element < Leptris::XML::Node
       indent: indent, no_decl: no_decl, encoding: encoding)
   end
 
+  # Nokogiri parity (leptris#1595): to_s serializes the node —
+  # the default Object#to_s object dump leaked into migrated
+  # consumers (coradoc math stems). Serialization options ride
+  # to_xml; to_s is the no-options convenience form.
+  def to_s
+    to_xml
+  end
+
   # HTML5 serialization of this element subtree (#309 — see
   # Document#to_html for the semantics).
   def to_html

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,43 @@
 ## [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
+
+- **XSD: inline anonymous complexType/simpleType capture
+  (#1592, PR #1596).** Elements carrying an inline anonymous type —
+  arguably the most common XSD spelling — got no content model:
+  instance validation silently skipped their content check and
+  `leptris_xsd_content_valid` answered −1. Inline types now capture
+  under a synthesized `element:NAME` slot (collision-free — `:`
+  cannot appear in xs: NCName type names): top-level elements and
+  every particle fall back to the inline capture when the type
+  attribute is absent, and local simpleType particles type their
+  text through the slot.
+
+
+
 ## [1.9.322] - 2026-10-08
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.322
+    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

@@ -4,6 +4,7 @@
  * grow the model (datatypes, facets, content models, identity
  * constraints) — this slice's contract is the API shape, the
  * xs:schema identity check, and the declaration enumeration. */
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -12,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);
@@ -32,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;
@@ -41,6 +45,20 @@ struct leptris_xsd_schema {
 
 static char* xsd_strdup(const char* s);
 
+/* #1592: capture an INLINE anonymous xs:complexType / xs:simpleType
+ * under a synthesized name ("element:NAME" — ':' cannot appear in
+ * xs: NCName type names, so the slot is collision-free). Returns 1
+ * when a capture happened. Forward decls below; definitions later
+ * in this file. */
+static int xsd_capture_inline(struct leptris_xsd_schema* s,
+                              LeptrisElement elem, const char* synth);
+static XsdCm* xsd_cm_new(XsdCmKind kind);
+static void xsd_cm_occurrence(XsdCm* cm, LeptrisElement e);
+static XsdCm* xsd_cm_parse(struct leptris_xsd_schema* s,
+                           LeptrisElement group, XsdCm** tail_out);
+static XsdSimple* xsd_capture_simple(LeptrisElement st);
+
+
 static XsdCm* xsd_cm_new(XsdCmKind kind) {
     XsdCm* cm = (XsdCm*)calloc(1, sizeof(*cm));
     if (!cm) return NULL;
@@ -73,7 +91,45 @@ static void xsd_cm_occurrence(XsdCm* cm, LeptrisElement e) {
 /* Recursive model build over sequence | choice | all | element |
  * any children. Returns the child list head; *tail_out receives
  * the list tail for sibling chaining. */
-static XsdCm* xsd_cm_parse(LeptrisElement group, XsdCm** tail_out) {
+/* #1592: capture an INLINE anonymous xs:complexType / xs:simpleType
+ * under a synthesized name ("element:NAME" — ':' cannot appear in
+ * xs: NCName type names, so the slot is collision-free). Returns 1
+ * when a capture happened. */
+static int xsd_capture_inline(struct leptris_xsd_schema* s,
+                              LeptrisElement elem, const char* synth) {
+    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 (strcmp(local, "complexType") == 0) {
+            XsdCm* root = xsd_cm_new(XSD_CM_SEQ);
+            if (!root) return 0;
+            root->name = xsd_strdup(synth);
+            root->first_child = xsd_cm_parse(s, e, NULL);
+            root->next = s->complex_types;
+            s->complex_types = root;
+            return 1;
+        }
+        if (strcmp(local, "simpleType") == 0) {
+            XsdSimple* captured = xsd_capture_simple(e);
+            if (!captured) return 0;
+            free(captured->name);
+            captured->name = xsd_strdup(synth);
+            captured->next = s->simple_types;
+            s->simple_types = captured;
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static XsdCm* xsd_cm_parse(struct leptris_xsd_schema* s,
+                           LeptrisElement group, XsdCm** tail_out) {
     XsdCm* head = NULL;
     XsdCm* tail = NULL;
     for (LeptrisNodeRef n =
@@ -92,7 +148,7 @@ static XsdCm* xsd_cm_parse(LeptrisElement group, XsdCm** tail_out) {
             cm = xsd_cm_new(strcmp(local, "sequence") == 0 ? XSD_CM_SEQ
                             : strcmp(local, "choice") == 0 ? XSD_CM_CHOICE
                                                            : XSD_CM_ALL);
-            if (cm) cm->first_child = xsd_cm_parse(e, NULL);
+            if (cm) cm->first_child = xsd_cm_parse(s, e, NULL);
         } else if (strcmp(local, "element") == 0) {
             cm = xsd_cm_new(XSD_CM_ELEMENT);
             if (cm) {
@@ -100,8 +156,17 @@ static XsdCm* xsd_cm_parse(LeptrisElement group, XsdCm** tail_out) {
                     leptris_element_attribute(e, "name");
                 if (!nm) nm = leptris_element_attribute(e, "ref");
                 cm->name = xsd_strdup(nm);
-                cm->type = xsd_strdup(
-                    leptris_element_attribute(e, "type"));
+                const char* pty =
+                    leptris_element_attribute(e, "type");
+                if (pty) {
+                    cm->type = xsd_strdup(pty);
+                } else if (s && nm) {
+                    /* #1592: inline anonymous type on the particle */
+                    char synth[512];
+                    snprintf(synth, sizeof(synth), "element:%s", nm);
+                    if (xsd_capture_inline(s, e, synth))
+                        cm->type = xsd_strdup(synth);
+                }
             }
         } else if (strcmp(local, "any") == 0) {
             cm = xsd_cm_new(XSD_CM_ANY);
@@ -140,7 +205,9 @@ static char* xsd_strdup(const char* s) {
 /* Capture one xs:simpleType's restriction model (slice 2). */
 static XsdSimple* xsd_capture_simple(LeptrisElement st) {
     const char* name = leptris_element_attribute(st, "name");
-    if (!name) return NULL; /* anonymous types ride their element */
+    /* Anonymous types ride their element — allowed: the caller
+     * renames the captured entry into its synthesized slot
+     * (#1592). */
 
     XsdSimple* simple = (XsdSimple*)calloc(1, sizeof(*simple));
     if (!simple) return NULL;
@@ -323,6 +390,24 @@ 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];
+                snprintf(synth, sizeof(synth), "element:%s", nm);
+                if (xsd_capture_inline(s, (LeptrisElement)n, synth)) {
+                    XsdElementDecl* d =
+                        (XsdElementDecl*)calloc(1, sizeof(*d));
+                    if (d) {
+                        d->name = xsd_strdup(nm);
+                        d->type = xsd_strdup(synth);
+                        d->next = s->elements;
+                        s->elements = d;
+                    }
+                }
             }
         } else if (strcmp(local, "complexType") == 0 && uri &&
                    !strcmp(uri, XSD_NS)) {
@@ -334,7 +419,7 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
                 if (root) {
                     root->name = xsd_strdup(nm);
                     root->first_child =
-                        xsd_cm_parse((LeptrisElement)n, NULL);
+                        xsd_cm_parse(s, (LeptrisElement)n, NULL);
                     root->next = s->complex_types;
                     s->complex_types = root;
                 }
@@ -403,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;
@@ -472,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

@@ -517,3 +517,210 @@ TEST(XsdValidate, NullTolerant) {
 }
 
 }  // namespace
+
+// ---- #1592: inline anonymous types ---------------------------------
+namespace {
+
+const char* k_anon_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+    "<xs:element name=\"book\">"
+    "<xs:complexType>"
+    "<xs:sequence>"
+    "<xs:element name=\"title\" type=\"xs:token\"/>"
+    "<xs:element name=\"author\" type=\"xs:token\"/>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "</xs:element>"
+    "</xs:schema>";
+
+TEST(XsdContent, AnonymousInlineComplexTypeCaptured) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile(k_anon_schema, strlen(k_anon_schema), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    /* the issue's exact symptom: content_valid answered -1 */
+    const char* good[] = {"title", "author"};
+    EXPECT_EQ(leptris_xsd_content_valid(s, "book", good, NULL, 2), 1);
+    const char* bad[] = {"author", "author", "isbn"};
+    EXPECT_EQ(leptris_xsd_content_valid(s, "book", bad, NULL, 3), 0);
+    const char* miss[] = {"author"};
+    EXPECT_EQ(leptris_xsd_content_valid(s, "book", miss, NULL, 1), 0);
+    leptris_xsd_free(s);
+}
+
+TEST(XsdValidate, AnonymousInlineValidatesEndToEnd) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile(k_anon_schema, strlen(k_anon_schema), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* good_x = "<book><title>t</title><author>a</author></book>";
+    LeptrisDocument good =
+        leptris_parse_string(good_x, strlen(good_x), &st);
+    ASSERT_NE(good, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, good), 1);
+    leptris_document_free(good);
+    /* the issue's instance: missing title, out-of-model isbn */
+    const char* bad_x =
+        "<book><author/><author/><isbn>9</isbn></book>";
+    LeptrisDocument bad = leptris_parse_string(bad_x, strlen(bad_x), &st);
+    ASSERT_NE(bad, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, bad), 0);
+    EXPECT_GE(leptris_xsd_error_count(s), 1u);
+    leptris_document_free(bad);
+    leptris_xsd_free(s);
+}
+
+TEST(XsdDatatypes, AnonymousInlineSimpleTypeOnParticle) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xsd =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:complexType name=\"t\">"
+        "<xs:sequence>"
+        "<xs:element name=\"score\">"
+        "<xs:simpleType>"
+        "<xs:restriction base=\"xs:integer\">"
+        "<xs:minInclusive value=\"1\"/>"
+        "</xs:restriction>"
+        "</xs:simpleType>"
+        "</xs:element>"
+        "</xs:sequence></xs:complexType>"
+        "<xs:element name=\"game\" type=\"t\"/>"
+        "</xs:schema>";
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* good_x = "<game><score>9</score></game>";
+    LeptrisDocument good = leptris_parse_string(good_x, strlen(good_x), &st);
+    ASSERT_NE(good, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, good), 1);
+    leptris_document_free(good);
+    const char* bad_x = "<game><score>0</score></game>";
+    LeptrisDocument bad = leptris_parse_string(bad_x, strlen(bad_x), &st);
+    ASSERT_NE(bad, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, bad), 0);
+    leptris_document_free(bad);
+    /* the synthesized slot resolves directly too */
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "element:score", "9"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "element:score", "0"), 0);
+    leptris_xsd_free(s);
+}
+
+}  // 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.322",
+  "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.322.0
+  version: 1.9.324.0
 platform: aarch64-linux
 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