leptris 1.9.322.0-arm-linux → 1.9.323.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cee9b20f52c63091762472a30171a262ba68b07d224c185f0c2041ac5cbbb2c0
-  data.tar.gz: 2b46b0177ffcac4acc6cf72ea8c6ea74699e34ea52b4daf79d9717a79b1d2540
+  metadata.gz: aec88add4bec210848479baab87f427800225cf3a8ae53bfe1bc78fa1156f48b
+  data.tar.gz: 8cca45b53702a981798c18a430b605444f96ecc976a59cf857b39868ef188615
 SHA512:
-  metadata.gz: 8741467809869420f3acd9a29050873fdf08bec22cde580712fe36f9b5c16b4881bbc7c00f0dd9d9f35fe624471d0facbc0fabda86b40e3f1d7e2746ef685843
-  data.tar.gz: 0b34105f9ead345f1319c72e6dd9159b52ebf2cc0b49a015634e622b935a618574da5e526af4a0c0de5f1639e9601518165e2ecef4fb0e948497b16e4ed32e47
+  metadata.gz: 901cb861c4aa4b6bce67397ce950042b07aa9f31b96e3929ed35869d61d39a6fc1d0ceab90ea550c37de35505cc8d63b243ac49593a770fa5f089e1f59735e4d
+  data.tar.gz: 70929559a5da15afc24e4770097c5fb8bdc765b11d7c0dfb6840b645a89062dd25b4b66366fa0fdf50d72d813b1454f3e9ecb9345d915c5df919c58450ffac19

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.323"
 # 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.323.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.323
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [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.323
     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>
 
@@ -41,6 +42,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 +88,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 +145,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 +153,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 +202,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 +387,21 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
                     d->next = s->elements;
                     s->elements = d;
                 }
+            } else if (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 +413,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;
                 }

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

@@ -517,3 +517,91 @@ 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

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.323",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.322.0
+  version: 1.9.323.0
 platform: arm-linux
 authors:
 - Ribose Inc.