leptris 1.9.331.0-aarch64-linux → 1.9.333.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d5bec9cdcf6ab2aaf75b3d2ed0e505cabf44230734514074bfc6d9e4277c7e7
-  data.tar.gz: 5345c0c049bd9e5aeab14492802f5a9106c5ce429ba2b92139a6260e26602351
+  metadata.gz: 98ae1dcb70070a749f8df3f2454bf8d51e020fe5c222f36ad994798dbf9df672
+  data.tar.gz: 1a034cda5efbd4a6998e43a30b203a4884be9a7623a4a58f324b13766012fe3a
 SHA512:
-  metadata.gz: a5b7f11e204fb2f807b9d2b162ed91b2783466575aa9fbc622efc1949fb397f0ae8040a5a648e84e55a92dbd52b8efe97786ec4d48a627127da70c3fb0d5c342
-  data.tar.gz: bd2aac14b94807b2d72c65340ea920f735db1bfc39793aa63511f8b3fcaf0718eb715cc74c67090ca9dd9900b2a22a73c47b883bc3c11ff063d87647fdef5b77
+  metadata.gz: 0cb18a00e9d4833788336925a4807d27b455d994f6025ae0b90a06a7932669314c5f26550e3201ad30716d92ed7ee8c0e18fac70fd1e15090a846670f8afb93c
+  data.tar.gz: b700e9de1094f955049cfef2263b890d25ef81c54b369289e92609c29df46739562b35b5d37a81bb51b1ce81c18db403c212963ee79312d41292ee3fd1b5e20e

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.331"
+LIBLEPTRIS_VERSION = "1.9.333"
 # 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.331.0"
+  VERSION = "1.9.333.0"
 end

data/lib/leptris/xml/cdata.rb

@@ -31,4 +31,8 @@ class Leptris::XML::CDATA < Leptris::XML::Text
       Leptris::XML::FFI.leptris_cdata_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
+
+  def to_s
+    "<![CDATA[#{content}]]>"
+  end
 end

data/lib/leptris/xml/comment.rb

@@ -31,4 +31,8 @@ class Leptris::XML::Comment < Leptris::XML::Node
       Leptris::XML::FFI.leptris_comment_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
+
+  def to_s
+    "<!--#{content}-->"
+  end
 end

data/lib/leptris/xml/entity_reference.rb

@@ -10,4 +10,8 @@ class Leptris::XML::EntityReference < Leptris::XML::Node
     Leptris::XML::FFI.leptris_entity_ref_node_name(c_ptr)
   end
   alias_method :node_name, :name
+
+  def to_s
+    "&#{name};"
+  end
 end

data/lib/leptris/xml/node.rb

@@ -8,6 +8,7 @@ class Leptris::XML::Node
     @c_ptr ||= ::FFI::Pointer.new(@c_address)
   end
 
+
   # The Integer twin of #c_ptr — reading it never materializes a
   # Pointer (the native faces take addresses).
   def c_address

data/lib/leptris/xml/processing_instruction.rb

@@ -50,6 +50,10 @@ class Leptris::XML::ProcessingInstruction < Leptris::XML::Node
     new_data
   end
 
+  def to_s
+    content.to_s.empty? ? "<?#{name}?>" : "<?#{name} #{content}?>"
+  end
+
   # Document-level PIs have no tree parent for leptris_node_unlink
   # — route through the document-level removal (libleptris 1.9.9,
   # #612), identity-matched by index so the right same-target PI

data/lib/leptris/xml/text.rb

@@ -36,4 +36,8 @@ class Leptris::XML::Text < Leptris::XML::Node
       Leptris::XML::FFI.leptris_text_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
+
+  def to_s
+    Leptris::XML::Serialization.escape_text(content)
+  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.331
+- libleptris v1.9.333
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,41 @@
 ## [Unreleased]
 
+## [1.9.333] - 2026-10-10
+
+### Added
+
+- **Regression pin: union `memberTypes` + inline anonymous members
+  (#1615, PR #1618).** The reported over-acceptance was not
+  reproducible on any engine artifact (main, the v1.9.331 tag,
+  every published gem binary — including through the full Ruby
+  binding path). The exact schema now asserts in CI through both
+  `leptris_xsd_simple_valid` and instance validation, so the
+  mixed-member semantics are verifiable binary-independent of any
+  binding environment.
+
+
+## [1.9.332] - 2026-10-09
+
+### Added
+
+- **XSD 1.1 — tier 2 (#1075, PR #1616).** Gated on
+  `xs:schema @version="1.1"`: `xs:assert` on complexTypes (direct
+  and derivation-nested; compiled once, evaluated per instance
+  through the engine's XPath 2 lane; evaluation errors are
+  failures); `xs:assertion` on simpleTypes (`$value` binds the
+  lexical, element context); `xs:openContent` interleave/suffix
+  (wildcard self-loops at the Thompson NFA's junction states;
+  `xs:defaultOpenContent` schema-wide with `appliesToEmpty`) and
+  `xs:alternative` conditional type assignment (first passing
+  test types the instance, declared type as fallback). Ten
+  red-first specs; ctest 1951/1951; 1.0 schemas unaffected.
+
+### Fixed
+
+- free the defaultOpenContent wildcard with the schema (xsd)
+
+
+
 ## [1.9.331] - 2026-10-09
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -36,11 +36,14 @@ struct leptris_xsd_schema {
     XsdElementDecl* elements;
     XsdCm* complex_types; /* name-carrying model roots */
     XsdGroupDef* groups;  /* top-level xs:group definitions */
+    XsdCm* default_open;  /* xs:defaultOpenContent wildcard */
+    int default_oc_empty; /* appliesToEmpty="true" */
     XsdAttrGroupDef* attr_groups;
     XsdAttrDecl* top_attrs; /* top-level xs:attribute declarations */
     XsdTypeAttrs* type_attrs;
     XsdElementIcs* element_ics;
     char* target_ns;
+    int version_11;    /* xs:schema @version = "1.1" */
     char* base_dir;    /* schemaLocation resolution (file compile) */
     int include_depth; /* include/import recursion guard */
     void* validator; /* slice-4 parked error list */
@@ -80,6 +83,12 @@ static void xsd_register_complex(struct leptris_xsd_schema* s,
 static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                                         LeptrisElement ct,
                                         const char* name);
+static XsdAssert* xsd_capture_assert(struct leptris_xsd_schema* s,
+                                     LeptrisElement e);
+static XsdCm* xsd_capture_any(LeptrisElement any_child);
+static void xsd_capture_alternatives(struct leptris_xsd_schema* s,
+                                     LeptrisElement decl_elem,
+                                     XsdElementDecl* d);
 static XsdSimple* xsd_capture_simple(LeptrisElement st);
 
 
@@ -95,6 +104,15 @@ static XsdCm* xsd_cm_new(XsdCmKind kind) {
 static void xsd_cm_free(XsdCm* cm) {
     while (cm) {
         XsdCm* next = cm->next;
+        XsdAssert* a = cm->asserts;
+        while (a) {
+            XsdAssert* an = a->next;
+            if (a->compiled) leptris_xquery_free(a->compiled);
+            free(a->test);
+            free(a);
+            a = an;
+        }
+        if (cm->oc_owned && cm->open_any) xsd_cm_free(cm->open_any);
         xsd_cm_free(cm->first_child);
         free(cm->name);
         free(cm->type);
@@ -370,6 +388,9 @@ static XsdSimple* xsd_capture_simple(LeptrisElement st) {
                     simple->fraction_digits = val ? strtol(val, NULL, 10) : -1;
                 else if (strcmp(fl, "whiteSpace") == 0)
                     simple->whitespace = xsd_strdup(val);
+                else if (strcmp(fl, "assertion") == 0)
+                    simple->assertion = xsd_strdup(
+                        leptris_element_attribute(fe, "test"));
             }
         }
     }
@@ -481,6 +502,7 @@ static int xsd_is_declaration(const char* local, const char* uri) {
     static const char* names[] = {
         "element",    "attribute",    "simpleType", "complexType",
         "group",      "attributeGroup", "notation", "include",
+        "defaultOpenContent",
         "import",     "redefine",     NULL
     };
     for (int i = 0; names[i]; i++)
@@ -594,6 +616,10 @@ static LeptrisXsdSchema xsd_compile_impl(const char* xsd_text,
     }
     s->target_ns = xsd_strdup(
         leptris_element_attribute(root, "targetNamespace"));
+    {
+        const char* ver = leptris_element_attribute(root, "version");
+        s->version_11 = (ver && strcmp(ver, "1.1") == 0);
+    }
 
     const char* local = NULL;
     const char* prefix = NULL;
@@ -692,6 +718,7 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                 if (d) {
                     d->name = xsd_strdup(nm);
                     d->type = xsd_strdup(ty);
+                    xsd_capture_alternatives(s, (LeptrisElement)n, d);
                     d->fixed = xsd_strdup(
                         leptris_element_attribute((LeptrisElement)n,
                                                   "fixed"));
@@ -730,6 +757,29 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                 leptris_element_attribute((LeptrisElement)n, "name");
             if (nm)
                 xsd_capture_complex_model(s, (LeptrisElement)n, nm);
+        } else if (strcmp(local, "defaultOpenContent") == 0 && uri &&
+                   !strcmp(uri, XSD_NS)) {
+            if (s->version_11) {
+                const char* ape = leptris_element_attribute(
+                    (LeptrisElement)n, "appliesToEmpty");
+                for (LeptrisNodeRef q = leptris_node_first_child(
+                         leptris_element_as_node((LeptrisElement)n));
+                     q && !s->default_open;
+                     q = leptris_node_next_sibling(q)) {
+                    if (leptris_node_get_type(q) !=
+                        LEPTRIS_NODE_TYPE_ELEMENT)
+                        continue;
+                    LeptrisElement qe = (LeptrisElement)q;
+                    const char* ql = NULL;
+                    leptris_element_expanded_name(qe, &ql, NULL, NULL);
+                    if (ql && strcmp(ql, "any") == 0)
+                        s->default_open = xsd_capture_any(qe);
+                }
+                if (s->default_open)
+                    s->default_oc_empty =
+                        (ape && strcmp(ape, "true") == 0);
+            }
+            continue;
         } else if (strcmp(local, "attribute") == 0 && uri && !strcmp(uri, XSD_NS)) {
             const char* nm =
                 leptris_element_attribute((LeptrisElement)n, "name");
@@ -803,6 +853,8 @@ static void xsd_free_simple_one(XsdSimple* t) {
     free(t->max_inclusive);
     free(t->max_exclusive);
     free(t->whitespace);
+    if (t->assertion_q) leptris_xquery_free(t->assertion_q);
+    free(t->assertion);
     free(t->item_type);
     xsd_free_simple_one(t->item_def);
     for (size_t i = 0; i < t->member_count; i++) free(t->members[i]);
@@ -854,6 +906,15 @@ LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
     XsdElementDecl* d = s->elements;
     while (d) {
         XsdElementDecl* dn = d->next;
+        XsdAlternative* a = d->alternatives;
+        while (a) {
+            XsdAlternative* an = a->next;
+            if (a->compiled) leptris_xquery_free(a->compiled);
+            free(a->test);
+            free(a->type);
+            free(a);
+            a = an;
+        }
         free(d->name);
         free(d->type);
         free(d->fixed);
@@ -894,6 +955,7 @@ LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
         free(g);
         g = gn;
     }
+    if (s->default_open) xsd_cm_free(s->default_open);
     free(s->target_ns);
     free(s->base_dir);
     if (s->validator)
@@ -952,6 +1014,90 @@ static void xsd_register_complex(struct leptris_xsd_schema* s,
     }
 }
 
+/* XSD 1.1: xs:alternative children of an element declaration. */
+static void xsd_capture_alternatives(struct leptris_xsd_schema* s,
+                                     LeptrisElement decl_elem,
+                                     XsdElementDecl* d) {
+    if (!s->version_11) return;
+    XsdAlternative* tail = NULL;
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(decl_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;
+        leptris_element_expanded_name(e, &local, NULL, NULL);
+        if (!local || strcmp(local, "alternative") != 0) continue;
+        const char* test = leptris_element_attribute(e, "test");
+        const char* type = leptris_element_attribute(e, "type");
+        if (!test || !type) continue;
+        XsdAlternative* a = (XsdAlternative*)calloc(1, sizeof(*a));
+        if (!a) continue;
+        a->test = xsd_strdup(test);
+        a->type = xsd_strdup(type);
+        a->compiled = leptris_xquery_parse(test, strlen(test));
+        if (tail)
+            tail->next = a;
+        else
+            d->alternatives = a;
+        tail = a;
+    }
+}
+
+static XsdCm* xsd_capture_any(LeptrisElement any_child) {
+    XsdCm* w = xsd_cm_new(XSD_CM_ANY);
+    if (!w) return NULL;
+    w->any_ns = xsd_strdup(
+        leptris_element_attribute(any_child, "namespace"));
+    const char* pc = leptris_element_attribute(any_child,
+                                               "processContents");
+    w->process_skip =
+        (pc && (strcmp(pc, "skip") == 0 || strcmp(pc, "lax") == 0))
+            ? 1
+            : 0;
+    w->min = 0;
+    w->max = -1;
+    return w;
+}
+
+static XsdAssert* xsd_capture_assert(struct leptris_xsd_schema* s,
+                                     LeptrisElement e) {
+    const char* test = leptris_element_attribute(e, "test");
+    if (!test || !*test) return NULL;
+    XsdAssert* a = (XsdAssert*)calloc(1, sizeof(*a));
+    if (!a) return NULL;
+    a->test = xsd_strdup(test);
+    if (s->version_11) {
+        a->compiled = leptris_xquery_parse(test, strlen(test));
+        /* NULL = syntax error: evaluation reports the assertion
+         * as failed (XSD 1.1: an error is a failure) */
+    }
+    return a;
+}
+
+/* Append every xs:assert child under `container` to the type. */
+static void xsd_capture_assert_children(
+    struct leptris_xsd_schema* s, LeptrisElement container,
+    XsdCm* root) {
+    XsdAssert* tail = root->asserts;
+    while (tail && tail->next) tail = tail->next;
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(container));
+         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;
+        leptris_element_expanded_name(e, &local, NULL, NULL);
+        if (!local || strcmp(local, "assert") != 0) continue;
+        XsdAssert* a = xsd_capture_assert(s, e);
+        if (!a) continue;
+        if (!root->asserts) root->asserts = a;
+        tail = a;
+    }
+}
+
 /* One complexType capture, shared by top-level declarations and
  * inline anonymous types: content model + derivation
  * (complexContent/simpleContent extension|restriction) + the
@@ -1026,6 +1172,9 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                     root->first_child = xsd_cm_parse(s, dq, NULL);
                     attrs = xsd_capture_attr_rows(s, dq, 0);
                 }
+                /* XSD 1.1: asserts nested under the derivation */
+                if (s->version_11)
+                    xsd_capture_assert_children(s, dq, root);
             }
         } else if (strcmp(local, "simpleContent") == 0) {
             for (LeptrisNodeRef q = leptris_node_first_child(
@@ -1093,6 +1242,50 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
         root->first_child = xsd_cm_parse(s, ct, NULL);
         if (!attrs) attrs = xsd_capture_attr_rows(s, ct, 0);
     }
+    /* XSD 1.1: openContent on the type, else the schema default */
+    if (s->version_11) {
+        for (LeptrisNodeRef n =
+                 leptris_node_first_child(leptris_element_as_node(ct));
+             n; n = leptris_node_next_sibling(n)) {
+            if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+                continue;
+            LeptrisElement e = (LeptrisElement)n;
+            const char* ocl = NULL;
+            leptris_element_expanded_name(e, &ocl, NULL, NULL);
+            if (!ocl || strcmp(ocl, "openContent") != 0) continue;
+            const char* mode = leptris_element_attribute(e, "mode");
+            for (LeptrisNodeRef q = leptris_node_first_child(
+                     leptris_element_as_node(e));
+                 q && !root->open_any;
+                 q = leptris_node_next_sibling(q)) {
+                if (leptris_node_get_type(q) !=
+                    LEPTRIS_NODE_TYPE_ELEMENT)
+                    continue;
+                LeptrisElement qe = (LeptrisElement)q;
+                const char* ql = NULL;
+                leptris_element_expanded_name(qe, &ql, NULL, NULL);
+                if (ql && strcmp(ql, "any") == 0) {
+                    root->open_any = xsd_capture_any(qe);
+                    if (root->open_any) root->oc_owned = 1;
+                }
+            }
+            if (mode && strcmp(mode, "suffix") == 0)
+                root->oc_mode = 1;
+            else if (mode && strcmp(mode, "interleave") == 0)
+                root->oc_mode = 2;
+            else
+                root->oc_mode = 0;
+        }
+    }
+    if (!root->oc_mode && s->default_open && root->first_child)
+        root->oc_mode = 2;
+    if (!root->oc_mode && s->default_open && !root->first_child &&
+        s->default_oc_empty)
+        root->oc_mode = 2;
+    if (root->oc_mode == 2 && !root->open_any && s->default_open)
+        root->open_any = s->default_open;
+    /* XSD 1.1: direct xs:assert children of the complexType */
+    if (s->version_11) xsd_capture_assert_children(s, ct, root);
     /* the NFA and model walkers consume ONE root particle —
      * a multi-particle model (derivation splices) normalizes
      * under a sequence */
@@ -1103,6 +1296,18 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
             root->first_child = seq;
         }
     }
+    /* open-content semantics ride the model root (the NFA builds
+     * from ct->first_child, never the name wrapper) */
+    if (root->first_child) {
+        root->first_child->open_any = root->open_any;
+        root->first_child->oc_mode = root->oc_mode;
+        root->first_child->oc_owned = root->oc_owned;
+        root->open_any = NULL;
+        root->oc_owned = 0;
+    } else if (root->open_any && root->oc_owned) {
+        xsd_cm_free(root->open_any);
+        root->open_any = NULL;
+    }
     xsd_register_complex(s, root, attrs, name);
     return root;
 }
@@ -1124,6 +1329,10 @@ int xsd_is_substitute(struct leptris_xsd_schema* s,
     return 0;
 }
 
+int xsd_schema_version_11(struct leptris_xsd_schema* s) {
+    return s ? s->version_11 : 0;
+}
+
 XsdGroupDef* xsd_find_group(struct leptris_xsd_schema* s,
                             const char* name) {
     if (!s || !name) return NULL;

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

@@ -56,20 +56,35 @@ static void cm_build_occurrence(CmNfa* n, XsdCm* node,
 /* chain the group children: first reads `from`, last writes `to`.
  * xs:all is evaluated in sequence order for now (its order-free
  * semantics arrive with slice 4's all-semantics pass). */
+/* XSD 1.1 open content: a wildcard self-loop at a junction lets
+ * any-namespace elements (per the wildcard's grammar) consume a
+ * child without advancing the model. */
+static void oc_loop(CmNfa* n, XsdCm* node, int state) {
+    if (!node->open_any || !node->oc_mode) return;
+    nfa_trans(n, state, 0, node->open_any, state);
+}
+
 static void cm_build_children(CmNfa* n, XsdCm* node, int from, int to) {
     XsdCm* c = node->first_child;
     if (!c) {
         nfa_trans(n, from, -1, NULL, to);
         return;
     }
+    int interleave =
+        (node->open_any && node->oc_mode == 2) ? 1 : 0;
     int cursor = from;
+    if (interleave) oc_loop(n, node, cursor);
     while (c->next) {
         int mid = nfa_state(n);
         cm_build_occurrence(n, c, cursor, mid);
         cursor = mid;
+        if (interleave) oc_loop(n, node, cursor);
         c = c->next;
     }
     cm_build_occurrence(n, c, cursor, to);
+    /* suffix (and interleave) wildcards may follow the sequence */
+    if (node->open_any && node->oc_mode)
+        oc_loop(n, node, to);
 }
 
 static void cm_build(CmNfa* n, XsdCm* node, int from, int to) {

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

@@ -8,6 +8,7 @@
  * accumulate in the schema-owned error list — the RNG accessor
  * pattern: validate returns 1/0, errors enumerate every miss.
  */
+#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -50,6 +51,7 @@ static void verr(struct leptris_xsd_schema* s, const char* fmt,
                  const char* a, const char* b);
 struct xsd_validator {
     struct leptris_xsd_schema* s;
+    LeptrisDocument doc; /* the instance (assertion evaluation) */
     struct xsd_error* errors;
     struct xsd_error* tail;
     size_t count;
@@ -89,13 +91,14 @@ static void verrf(struct xsd_validator* v, const char* what,
 static int text_valid(struct xsd_validator* v,
                       struct leptris_xsd_schema* s, const char* type,
                       const char* lexical, const char* what,
-                      const char* name) {
+                      const char* name, LeptrisElement elem) {
     if (!type) return 1;
     int r;
+    const XsdSimple* st = NULL;
     if (strncmp(type, "xs:", 3) == 0)
         r = xsd_builtin_valid(type, lexical);
     else {
-        const XsdSimple* st = xsd_find_simple_pub(s, type);
+        st = xsd_find_simple_pub(s, type);
         if (!st) return 1; /* unresolved: accept */
         r = xsd_simple_valid_chain(s, st, lexical);
     }
@@ -103,6 +106,61 @@ static int text_valid(struct xsd_validator* v,
         verrf(v, what, name, "lexical value does not match its type");
         return 0;
     }
+    /* XSD 1.1 xs:assertion facet (document validation only):
+     * $value binds the lexical — numeric lexicals bind bare,
+     * everything else as a string — and the context is the
+     * owning element. */
+    if (st && st->assertion && elem && v->doc) {
+        XsdSimple* mut = (XsdSimple*)st;
+        if (!mut->assertion_tried) {
+            mut->assertion_tried = 1;
+            if (xsd_schema_version_11(s)) {
+                /* eval_params binds DECLARED external variables —
+                 * the test compiles under a $value declaration */
+                char wrapped[1024];
+                int w = snprintf(wrapped, sizeof(wrapped),
+                                 "declare variable $value external; %s",
+                                 mut->assertion);
+                if (w > 0 && (size_t)w < sizeof(wrapped))
+                    mut->assertion_q =
+                        leptris_xquery_parse(wrapped, (size_t)w);
+            }
+        }
+        if (mut->assertion_q) {
+            char sel[256];
+            int numeric = 1;
+            for (const char* p = lexical; *p; p++)
+                if (!isdigit((unsigned char)*p) && *p != '.' &&
+                    *p != '-' && *p != '+' && *p != 'e' && *p != 'E')
+                    numeric = 0;
+            if (numeric && *lexical)
+                snprintf(sel, sizeof(sel), "%s", lexical);
+            else {
+                size_t w = 0;
+                sel[w++] = '\'';
+                for (const char* p = lexical; *p && w < sizeof(sel) - 3;
+                     p++) {
+                    if (*p == '\'') sel[w++] = '\'';
+                    sel[w++] = *p;
+                }
+                sel[w++] = '\'';
+                sel[w] = 0;
+            }
+            const char* names[1] = {"value"};
+            const char* sels[1] = {sel};
+            LeptrisXPathResult r2 = leptris_xquery_eval_params(
+                mut->assertion_q, v->doc, elem, names, sels, 1);
+            int ebv = 0;
+            if (r2) {
+                ebv = leptris_xpath_result_boolean(r2);
+                leptris_xpath_result_free(r2);
+            }
+            if (!ebv) {
+                verrf(v, what, name, "assertion failed");
+                return 0;
+            }
+        }
+    }
     return 1;
 }
 
@@ -231,7 +289,7 @@ static void validate_attributes(struct xsd_validator* v,
                 verrf(v, "attribute", a->name, "required but absent");
             continue;
         }
-        text_valid(v, s, a->type, val, "attribute", a->name);
+        text_valid(v, s, a->type, val, "attribute", a->name, elem);
         if (a->fixed && strcmp(val, a->fixed) != 0)
             verrf(v, "attribute", a->name,
                   "value does not match the fixed value");
@@ -248,14 +306,32 @@ static void validate_element(struct xsd_validator* v,
     const XsdElementDecl* d = xsd_find_element(s, local);
     if (!d) return; /* undeclared: lax at this depth (strict later) */
 
-    if (!d->type) return; /* anyType */
+    /* XSD 1.1: the first alternative whose test passes types the
+     * element for this instance (context = the element). */
+    const char* eff_type = d->type;
+    for (XsdAlternative* alt = d->alternatives; alt; alt = alt->next) {
+        int ebv = 0;
+        if (alt->compiled && v->doc) {
+            LeptrisXPathResult r =
+                leptris_xquery_eval(alt->compiled, v->doc, elem);
+            if (r) {
+                ebv = leptris_xpath_result_boolean(r);
+                leptris_xpath_result_free(r);
+            }
+        }
+        if (ebv) {
+            eff_type = alt->type;
+            break;
+        }
+    }
+    if (!eff_type) return; /* anyType */
     if (d->fixed) {
         const char* text = leptris_element_text(elem);
         if (text && *text && strcmp(text, d->fixed) != 0)
             verrf(v, "element", local,
                   "content does not match the fixed value");
     }
-    validate_local(v, s, elem, local, d->type);
+    validate_local(v, s, elem, local, eff_type);
 }
 
 /* Validate one element against a type name that comes from a
@@ -270,11 +346,27 @@ static void validate_local(struct xsd_validator* v,
     if (ct) {
         validate_attributes(v, s, elem, xsd_find_type_attrs(s, type));
         validate_children(v, s, elem, ct);
+        /* XSD 1.1: the type's xs:assert list — context is the
+         * element; evaluation errors are failures */
+        for (XsdAssert* a = ct->asserts; a; a = a->next) {
+            int ebv = 0;
+            if (a->compiled && v->doc) {
+                LeptrisXPathResult r =
+                    leptris_xquery_eval(a->compiled, v->doc, elem);
+                if (r) {
+                    ebv = leptris_xpath_result_boolean(r);
+                    leptris_xpath_result_free(r);
+                }
+            }
+            if (!ebv)
+                verrf(v, "assertion", local, a->test ? a->test
+                                                     : "(invalid)");
+        }
         if (ct->text_type) {
             const char* text = leptris_element_text(elem);
             if (text && *text)
                 text_valid(v, s, ct->text_type, text, "element",
-                           local);
+                           local, elem);
         }
         return;
     }
@@ -284,7 +376,7 @@ static void validate_local(struct xsd_validator* v,
         xsd_find_simple_pub(s, type)) {
         const char* text = leptris_element_text(elem);
         if (text && *text)
-            text_valid(v, s, type, text, "element", local);
+            text_valid(v, s, type, text, "element", local, elem);
     }
 }
 
@@ -509,6 +601,7 @@ void xsd_validator_free(struct xsd_validator* v) {
 
 int xsd_validator_run(struct xsd_validator* v, LeptrisDocument doc) {
     if (!v || !doc) return -1;
+    v->doc = doc; /* XSD 1.1: assertion evaluation context */
     LeptrisElement root = leptris_document_root(doc);
     if (!root) return -1;
     validate_element(v, v->s, root, 0);

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

@@ -5,6 +5,8 @@
 
 #include <stddef.h>
 
+#include "../../include/leptris/xquery/xquery.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -57,6 +59,9 @@ typedef struct xsd_simple {
     long total_digits;
     long fraction_digits;
     char* whitespace; /* "preserve" | "replace" | "collapse" */
+    char* assertion; /* XSD 1.1: the xs:assertion test text */
+    LeptrisXQuery assertion_q; /* compiled lazily at first use */
+    int assertion_tried;       /* lazy-compile guard */
     struct xsd_simple* next;
 } XsdSimple;
 
@@ -65,6 +70,15 @@ typedef struct xsd_simple {
 int xsd_simple_valid_chain(struct leptris_xsd_schema* s,
                            const XsdSimple* t, const char* v);
 
+/* XSD 1.1 (#1075 tier 2): one xs:assert bound to a complexType —
+ * the compiled XPath 2 test plus its source text. Evaluation
+ * errors count as assertion failure. */
+typedef struct xsd_assert {
+    char* test;             /* the wire expression, for reporting */
+    LeptrisXQuery compiled; /* NULL when compilation failed */
+    struct xsd_assert* next;
+} XsdAssert;
+
 /* Content-model node: a particle (element ref / wildcard) or a
  * group (sequence | choice | all). Owned by the schema; freed
  * with the schema. */
@@ -88,8 +102,14 @@ typedef struct xsd_cm {
     struct xsd_cm* first_child; /* group children list */
     struct xsd_cm* next;        /* sibling link within the parent group */
     char* text_type; /* simpleContent wrapper: the text's type ref */
+    XsdAssert* asserts; /* XSD 1.1: the type's xs:assert list */
+    struct xsd_cm* open_any; /* XSD 1.1: xs:openContent wildcard */
+    int oc_mode;        /* 0 none/unset, 1 suffix, 2 interleave */
+    int oc_owned;       /* the wildcard node is this model's own */
 } XsdCm;
 
+
+
 /* A top-level xs:group definition: name + the model its refs
  * splice in (the definition's single sequence/choice/all). */
 typedef struct xsd_group_def {
@@ -98,15 +118,28 @@ typedef struct xsd_group_def {
     struct xsd_group_def* next;
 } XsdGroupDef;
 
+/* XSD 1.1 (xs:schema @version="1.1") gates 1.1 enforcement. */
+int xsd_schema_version_11(struct leptris_xsd_schema* s);
+
 /* Group refs resolve through the schema at NFA-build time —
  * forward references need no capture order. */
 XsdGroupDef* xsd_find_group(struct leptris_xsd_schema* s,
                             const char* name);
 
+/* XSD 1.1 (#1075 tier 2): one xs:alternative on an element
+ * declaration — the test plus the type it selects. */
+typedef struct xsd_alternative {
+    char* test;             /* wire text, for reporting */
+    LeptrisXQuery compiled; /* NULL when compilation failed */
+    char* type;             /* the selected type name */
+    struct xsd_alternative* next;
+} XsdAlternative;
+
 /* A top-level xs:element declaration (slice 3: name + type ref). */
 typedef struct xsd_element_decl {
     char* name;
     char* type;     /* "xs:string"-style builtin or a local type name */
+    XsdAlternative* alternatives; /* XSD 1.1 conditional types */
     char* fixed;    /* fixed element content: text must string-equal it */
     char* sub_head; /* substitutionGroup head (local name after ':') */
     struct xsd_element_decl* next;

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

@@ -1119,3 +1119,280 @@ TEST(XsdCompileFile, MissingFileIsNullWithStatus) {
 }
 
 }  // namespace
+
+// ---- tier 2 (#1075): xs:assert --------------------------------------
+namespace {
+
+const char* k_assert_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:complexType name=\"boxT\">"
+    "<xs:sequence>"
+    "<xs:element name=\"item\" type=\"xs:token\" minOccurs=\"0\""
+    " maxOccurs=\"unbounded\"/>"
+    "</xs:sequence>"
+    "<xs:attribute name=\"qty\" type=\"xs:integer\"/>"
+    "<xs:assert test=\"count(item) &lt;= 2\"/>"
+    "</xs:complexType>"
+    "<xs:element name=\"box\" type=\"boxT\"/>"
+    "</xs:schema>";
+
+TEST(XsdAssert11, ComplexTypeAssertionEnforces) {
+    EXPECT_EQ(validate_doc(k_assert_schema,
+                           "<box qty=\"1\"><item>a</item>"
+                           "</box>"), 1);
+    EXPECT_EQ(validate_doc(k_assert_schema,
+                           "<box qty=\"1\"><item>a</item><item>b</item>"
+                           "</box>"), 1);
+    /* the assertion fails at three items */
+    EXPECT_EQ(validate_doc(k_assert_schema,
+                           "<box qty=\"1\"><item>a</item><item>b</item>"
+                           "<item>c</item></box>"), 0);
+    /* attributes ride the assertion context too */
+    EXPECT_EQ(validate_doc(k_assert_schema,
+                           "<box qty=\"9\"><item>a</item>"
+                           "<item>b</item><item>c</item></box>"), 0);
+}
+
+const char* k_assert_attr_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:complexType name=\"pairT\">"
+    "<xs:attribute name=\"lo\" type=\"xs:integer\"/>"
+    "<xs:attribute name=\"hi\" type=\"xs:integer\"/>"
+    "<xs:assert test=\"number(@lo) &lt;= number(@hi)\"/>"
+    "</xs:complexType>"
+    "<xs:element name=\"p\" type=\"pairT\"/>"
+    "</xs:schema>";
+
+TEST(XsdAssert11, AttributeComparisonAssertion) {
+    EXPECT_EQ(validate_doc(k_assert_attr_schema,
+                           "<p lo=\"1\" hi=\"3\"/>"), 1);
+    EXPECT_EQ(validate_doc(k_assert_attr_schema,
+                           "<p lo=\"4\" hi=\"3\"/>"), 0);
+}
+
+/* assertions nested under complexContent/extension also bind */
+TEST(XsdAssert11, ExtensionAssertionEnforces) {
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " version=\"1.1\">"
+        "<xs:complexType name=\"baseT\">"
+        "<xs:sequence><xs:element name=\"a\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "</xs:complexType>"
+        "<xs:complexType name=\"extT\">"
+        "<xs:complexContent>"
+        "<xs:extension base=\"baseT\">"
+        "<xs:sequence><xs:element name=\"b\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "<xs:assert test=\"a = b\"/>"
+        "</xs:extension>"
+        "</xs:complexContent>"
+        "</xs:complexType>"
+        "<xs:element name=\"e\" type=\"extT\"/>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(x, "<e><a>t</a><b>t</b></e>"), 1);
+    EXPECT_EQ(validate_doc(x, "<e><a>t</a><b>u</b></e>"), 0);
+}
+
+/* 1.0-labelled schemas ignore the construct (XSD 1.0 validators
+ * see unknown elements) — no assertion enforcement */
+TEST(XsdAssert11, Version10IgnoresAssertions) {
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " version=\"1.0\">"
+        "<xs:complexType name=\"boxT\">"
+        "<xs:sequence>"
+        "<xs:element name=\"item\" type=\"xs:token\" minOccurs=\"0\""
+        " maxOccurs=\"unbounded\"/>"
+        "</xs:sequence>"
+        "<xs:assert test=\"count(item) &lt;= 1\"/>"
+        "</xs:complexType>"
+        "<xs:element name=\"box\" type=\"boxT\"/>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(x,
+                           "<box><item>a</item><item>b</item></box>"), 1);
+}
+
+}  // namespace
+
+// ---- tier 2 (#1075): xs:assertion on simpleTypes -------------------
+namespace {
+
+const char* k_sa_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:simpleType name=\"small\">"
+    "<xs:restriction base=\"xs:integer\">"
+    "<xs:assertion test=\"$value &lt; 10\"/>"
+    "</xs:restriction>"
+    "</xs:simpleType>"
+    "<xs:simpleType name=\"word\">"
+    "<xs:restriction base=\"xs:string\">"
+    "<xs:assertion test=\"string-length($value) &lt;= 3\"/>"
+    "</xs:restriction>"
+    "</xs:simpleType>"
+    "<xs:element name=\"n\" type=\"small\"/>"
+    "<xs:element name=\"w\" type=\"word\"/>"
+    "</xs:schema>";
+
+TEST(XsdAssertion11, SimpleTypeValueAssertions) {
+    EXPECT_EQ(validate_doc(k_sa_schema, "<n>5</n>"), 1);
+    EXPECT_EQ(validate_doc(k_sa_schema, "<n>50</n>"), 0);
+    EXPECT_EQ(validate_doc(k_sa_schema, "<w>abc</w>"), 1);
+    EXPECT_EQ(validate_doc(k_sa_schema, "<w>abcd</w>"), 0);
+}
+
+}  // namespace
+
+// ---- tier 2 (#1075): open content ----------------------------------
+namespace {
+
+const char* k_oc_interleave =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:complexType name=\"tT\">"
+    "<xs:sequence>"
+    "<xs:element name=\"a\" type=\"xs:token\"/>"
+    "<xs:element name=\"b\" type=\"xs:token\"/>"
+    "</xs:sequence>"
+    "<xs:openContent mode=\"interleave\">"
+    "<xs:any namespace=\"##any\" processContents=\"lax\"/>"
+    "</xs:openContent>"
+    "</xs:complexType>"
+    "<xs:element name=\"e\" type=\"tT\"/>"
+    "</xs:schema>";
+
+TEST(XsdOpenContent11, InterleavedWildcardsBindAnywhere) {
+    /* the plain sequence */
+    EXPECT_EQ(validate_doc(k_oc_interleave,
+                           "<e><a>1</a><b>2</b></e>"), 1);
+    /* foreign element before, between, after */
+    EXPECT_EQ(validate_doc(k_oc_interleave,
+                           "<e><q/><a>1</a><b>2</b></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_interleave,
+                           "<e><a>1</a><q/><b>2</b></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_interleave,
+                           "<e><a>1</a><b>2</b><q/></e>"), 1);
+    /* the sequence itself still enforces order */
+    EXPECT_EQ(validate_doc(k_oc_interleave,
+                           "<e><b>2</b><a>1</a></e>"), 0);
+}
+
+const char* k_oc_suffix =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:complexType name=\"tT\">"
+    "<xs:sequence>"
+    "<xs:element name=\"a\" type=\"xs:token\"/>"
+    "</xs:sequence>"
+    "<xs:openContent mode=\"suffix\">"
+    "<xs:any namespace=\"##any\" processContents=\"lax\"/>"
+    "</xs:openContent>"
+    "</xs:complexType>"
+    "<xs:element name=\"e\" type=\"tT\"/>"
+    "</xs:schema>";
+
+TEST(XsdOpenContent11, SuffixWildcardsBindOnlyAtTheEnd) {
+    EXPECT_EQ(validate_doc(k_oc_suffix, "<e><a>1</a><q/></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_suffix, "<e><a>1</a><q/><r/></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_suffix, "<e><q/><a>1</a></e>"), 0);
+}
+
+const char* k_oc_default =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:defaultOpenContent mode=\"interleave\">"
+    "<xs:any namespace=\"##any\" processContents=\"lax\"/>"
+    "</xs:defaultOpenContent>"
+    "<xs:complexType name=\"tT\">"
+    "<xs:sequence>"
+    "<xs:element name=\"a\" type=\"xs:token\"/>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "<xs:element name=\"e\" type=\"tT\"/>"
+    "</xs:schema>";
+
+TEST(XsdOpenContent11, DefaultOpenContentApplies) {
+    EXPECT_EQ(validate_doc(k_oc_default, "<e><a>1</a></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_default, "<e><a>1</a><q/></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_default, "<e><q/><a>1</a></e>"), 1);
+}
+
+}  // namespace
+
+// ---- tier 2 (#1075): conditional type assignment --------------
+namespace {
+
+const char* k_alt_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:complexType name=\"circleT\">"
+    "<xs:sequence><xs:element name=\"r\" type=\"xs:integer\"/>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "<xs:complexType name=\"squareT\">"
+    "<xs:sequence><xs:element name=\"s\" type=\"xs:string\"/>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "<xs:complexType name=\"fallbackT\">"
+    "<xs:sequence><xs:element name=\"u\" type=\"xs:token\"/>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "<xs:element name=\"shape\" type=\"fallbackT\">"
+    "<xs:alternative test=\"@kind = 'circle'\" type=\"circleT\"/>"
+    "<xs:alternative test=\"@kind = 'square'\" type=\"squareT\"/>"
+    "</xs:element>"
+    "</xs:schema>";
+
+TEST(XsdAlternative11, FirstMatchingAlternativeTypes) {
+    /* circle alternative */
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"circle\"><r>2</r></shape>"), 1);
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"circle\"><r>x</r></shape>"), 0);
+    /* square alternative */
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"square\"><s>hi</s></shape>"), 1);
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"square\"><r>2</r></shape>"), 0);
+    /* no alternative matches: the declared fallback type applies */
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"blob\"><u>t</u></shape>"), 1);
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"blob\"><r>2</r></shape>"), 0);
+}
+
+}  // namespace
+
+/* #1615 regression pin: a union combining memberTypes with inline
+ * anonymous members consults BOTH member sets (the issue reported
+ * over-acceptance through a stale binding binary; the engine was
+ * verified correct on main, the tag, and every published gem —
+ * this pins the behavior in CI, binary-independent). */
+TEST(XsdDatatypes, UnionMixesNamedAndInlineMembers) {
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:simpleType name=\"intOrAuto\">"
+        "<xs:union memberTypes=\"xs:integer\">"
+        "<xs:simpleType>"
+        "<xs:restriction base=\"xs:token\">"
+        "<xs:enumeration value=\"auto\"/>"
+        "</xs:restriction>"
+        "</xs:simpleType>"
+        "</xs:union>"
+        "</xs:simpleType>"
+        "<xs:element name=\"v\" type=\"intOrAuto\"/>"
+        "</xs:schema>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(x, strlen(x), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "intOrAuto", "42"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "intOrAuto", "auto"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "intOrAuto", "zz"), 0);
+    leptris_xsd_free(s);
+    EXPECT_EQ(validate_doc(x, "<v>zz</v>"), 0);
+    EXPECT_EQ(validate_doc(x, "<v>42</v>"), 1);
+    EXPECT_EQ(validate_doc(x, "<v>auto</v>"), 1);
+}

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.331",
+  "version": "1.9.333",
   "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.331.0
+  version: 1.9.333.0
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-09 00:00:00.000000000 Z
+date: 2026-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi