leptris 1.9.361.1-aarch64-linux → 1.9.362.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b0feccaefb9cbdc6449fa2e47a680f5b1bcd5e78674f09d6550f44808be9e25
-  data.tar.gz: 34b21f17675ec5b2b080634a9807b9a763c61ec7264fc98c186edabcd11b9671
+  metadata.gz: '04105926cfd0960392941a093f594a01194329e6e49f221d73497115b0ae9652'
+  data.tar.gz: 47c3bdcd81a95aa51352aa7eeb7d9a771ff623b9d8e34b823dc689edd9d05474
 SHA512:
-  metadata.gz: 29d9b33e704329a0f25f035dfdf6c69685bbaed5c50a1668b838889d490ac9b141fd2cd1a19193e4232dc5ac92703d76904ad7c4e81d97abd861fdbe0585207d
-  data.tar.gz: 1983b48645175192c5331dc5b95874b6abe290f257ba04979f464c87a823a06df8ed181aa0799bee27d38a02e8f22748f084408410654ef4adb7c7d0d47812e7
+  metadata.gz: 19e028d14722a7fdb8faccb32c68f158284d54dccf3f291ec851b5dc7214c4dc07185fcefb90aef2575832c55a4e3b6e8c80c4720b1596f6bc9d1417a441dec3
+  data.tar.gz: 03cf68de62e693e4391eed16b787bbe4758faae7bafced51b7cb13261e57a61d162db34bd02783fa1d699169c5415c30e7b153d44c4dd2bb575e849f9ba03fea

data/README.adoc

@@ -17,6 +17,27 @@ The C DOM is the single source of truth — Ruby objects are thin FFI
 handles over the C pointers, so every Ruby method maps to one FFI call.
 No tree hydration, no parallel Ruby-side model.
 
+== Versioning: {engine-semver}.{binding-patch}
+
+Gem versions are **`{libleptris-semver}.{binding-patch}`** — the lockstep
+scheme. The first three components name the EXACT libleptris engine
+release the gem vendors; the fourth is the binding's own patch number
+for that engine.
+
+* engine `v1.9.361` + first binding release → `1.9.361.0`
+* binding-only fix on the same engine → `1.9.361.1`
+* engine `v1.9.362` ride → `1.9.362.0`
+
+The triple is a contract: `~> 1.9.361` pins both the engine behavior
+and the binding surface. **Never** publish a version whose first three
+components are not an existing engine release, never let the binding
+line run ahead of the engine line, and every engine release must get
+its binding ride (`.0`, or `.1` when the ride itself carries binding
+fixes). Releases go through the release workflow with an explicit
+`next_version` — the workflow owns the bump; version numbers are
+computed from the engine tag being ridden, never from
+"previous gem + 1".
+
 == Installation
 
 Add to your Gemfile:

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.361"
+LIBLEPTRIS_VERSION = "1.9.362"
 # 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.361.1"
+  VERSION = "1.9.362.1"
 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.361
+- libleptris v1.9.362
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [1.9.362] - 2026-10-16
+
+### Fixed
+
+- **xsd: per-unit wildcard provenance for `##other` / `##targetNamespace` across imports (#1735, PR #1744).** `xs:any`/`xs:anyAttribute` namespace lists resolve the two unit-relative tokens against the target namespace of the schema unit DECLARING the wildcard, not the merged schema's main tns. Every wildcard now records its declaring unit's tns at capture (`XsdCm.any_unit_tns` for particles; `any_attr_unit_ns` / `any_attr_base_unit_ns` on the type atom for attribute wildcards, threading the #1723 `any_attr_base_ns` precedent across the unit boundary), and `any_ns_matches` / `any_attr_matches` resolve against it with the merged tns as fallback. Red-first gtests pin the element and attribute forms.
+
+
 ## [1.9.361] - 2026-10-15
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -96,13 +96,16 @@ static XsdAttrDecl* xsd_copy_attr_rows(const XsdAttrDecl* src);
 static void xsd_register_complex(struct leptris_xsd_schema* s,
                                  XsdCm* root, XsdAttrDecl* attrs,
                                  const char* name, char* any_attr_ns,
-                                 char* base_any_attr_ns);
+                                 char* any_attr_unit_ns,
+                                 char* base_any_attr_ns,
+                                 char* base_any_attr_unit_ns);
 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 char* xsd_capture_unit_tns(LeptrisElement e);
 static char* xsd_capture_any_attr_ns(LeptrisElement container);
 
 /* #1626: prefixed QName refs (type="w:CT_Border") resolve by local
@@ -168,6 +171,7 @@ static void xsd_cm_free(XsdCm* cm) {
         free(cm->ns);
         free(cm->ext_base);
         free(cm->any_ns);
+        free(cm->any_unit_tns);
         free(cm->text_type);
         free(cm);
         cm = next;
@@ -270,6 +274,7 @@ static XsdCm* xsd_cm_parse(struct leptris_xsd_schema* s,
             if (cm) {
                 cm->any_ns = xsd_strdup(
                     leptris_element_attribute(e, "namespace"));
+                cm->any_unit_tns = xsd_capture_unit_tns(e);
                 const char* pc = leptris_element_attribute(
                     e, "processContents");
                 cm->process_skip =
@@ -1968,9 +1973,14 @@ static void xsd_resolve_extension_bases(struct leptris_xsd_schema* s) {
                         mine->attrs = prepend;
                     }
                     /* the base's attribute wildcard joins the union */
-                    if (bt->any_attr_ns && !mine->any_attr_base_ns)
+                    if (bt->any_attr_ns && !mine->any_attr_base_ns) {
+                        mine->any_attr_base_unit_ns =
+                            bt->any_attr_unit_ns
+                                ? xsd_strdup(bt->any_attr_unit_ns)
+                                : NULL;
                         mine->any_attr_base_ns =
                             xsd_strdup(bt->any_attr_ns);
+                    }
                 } else if (prepend) {
                     XsdTypeAttrs* row =
                         (XsdTypeAttrs*)calloc(1, sizeof(*row));
@@ -2355,6 +2365,8 @@ LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
         free(ta->type_name);
         free(ta->any_attr_ns);
         free(ta->any_attr_base_ns);
+        free(ta->any_attr_unit_ns);
+        free(ta->any_attr_base_unit_ns);
         free(ta);
         ta = tn;
     }
@@ -2441,6 +2453,7 @@ static XsdCm* xsd_cm_copy_list(const XsdCm* head) {
         d->type = xsd_strdup(src->type);
         d->ns = xsd_strdup(src->ns);
         d->any_ns = xsd_strdup(src->any_ns);
+        d->any_unit_tns = xsd_strdup(src->any_unit_tns);
         d->process_skip = src->process_skip;
         d->min = src->min;
         d->max = src->max;
@@ -2457,7 +2470,9 @@ static XsdCm* xsd_cm_copy_list(const XsdCm* head) {
 static void xsd_register_complex(struct leptris_xsd_schema* s,
                                  XsdCm* root, XsdAttrDecl* attrs,
                                  const char* name, char* any_attr_ns,
-                                 char* base_any_attr_ns) {
+                                 char* any_attr_unit_ns,
+                                 char* base_any_attr_ns,
+                                 char* base_any_attr_unit_ns) {
     if (!root) return;
     root->name = xsd_strdup(name);
     /* leptris-ruby#440: the DECLARING file's targetNamespace — the
@@ -2475,12 +2490,16 @@ static void xsd_register_complex(struct leptris_xsd_schema* s,
             ta->attrs = attrs;
             ta->any_attr_ns = any_attr_ns;
             ta->any_attr_base_ns = base_any_attr_ns;
+            ta->any_attr_unit_ns = any_attr_unit_ns;
+            ta->any_attr_base_unit_ns = base_any_attr_unit_ns;
             ta->next = s->type_attrs;
             s->type_attrs = ta;
         }
     } else {
         free(any_attr_ns);
+        free(any_attr_unit_ns);
         free(base_any_attr_ns);
+        free(base_any_attr_unit_ns);
     }
 }
 
@@ -2520,6 +2539,7 @@ static XsdCm* xsd_capture_any(LeptrisElement any_child) {
     if (!w) return NULL;
     w->any_ns = xsd_strdup(
         leptris_element_attribute(any_child, "namespace"));
+    w->any_unit_tns = xsd_capture_unit_tns(any_child);
     const char* pc = leptris_element_attribute(any_child,
                                                "processContents");
     w->process_skip =
@@ -2579,7 +2599,9 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
     if (!root) return NULL;
     XsdAttrDecl* attrs = NULL;
     char* any_attr_ns = NULL;
+    char* any_attr_unit_ns = NULL;
     char* base_any_attr_ns = NULL;
+    char* base_any_attr_unit_ns = NULL;
 
     for (LeptrisNodeRef n =
              leptris_node_first_child(leptris_element_as_node(ct));
@@ -2651,9 +2673,14 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                         /* the spec's attribute-wildcard union: the
                          * derived type also allows what the base's
                          * xs:anyAttribute allowed (#1691) */
-                        if (bt && bt->any_attr_ns && !base_any_attr_ns)
+                        if (bt && bt->any_attr_ns && !base_any_attr_ns) {
+                            base_any_attr_unit_ns =
+                                bt->any_attr_unit_ns
+                                    ? xsd_strdup(bt->any_attr_unit_ns)
+                                    : NULL;
                             base_any_attr_ns =
                                 xsd_strdup(bt->any_attr_ns);
+                        }
                     }
                     XsdAttrDecl* own_attrs =
                         xsd_capture_attr_rows(s, dq, 0);
@@ -2674,6 +2701,8 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                 if (s->version_11)
                     xsd_capture_assert_children(s, dq, root);
                 if (!any_attr_ns)
+                    if (!any_attr_unit_ns)
+                        any_attr_unit_ns = xsd_capture_unit_tns(dq);
                     any_attr_ns = xsd_capture_any_attr_ns(dq);
             }
         } else if (strcmp(local, "simpleContent") == 0) {
@@ -2743,6 +2772,8 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
          * re-capturing would orphan those rows. */
         root->first_child = xsd_cm_parse(s, ct, NULL);
         if (!attrs) attrs = xsd_capture_attr_rows(s, ct, 0);
+        if (!any_attr_unit_ns)
+            any_attr_unit_ns = xsd_capture_unit_tns(ct);
         if (!any_attr_ns) any_attr_ns = xsd_capture_any_attr_ns(ct);
     }
     /* XSD 1.1: openContent on the type, else the schema default */
@@ -2812,7 +2843,8 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
         root->open_any = NULL;
     }
     xsd_register_complex(s, root, attrs, name, any_attr_ns,
-                          base_any_attr_ns);
+                          any_attr_unit_ns, base_any_attr_ns,
+                          base_any_attr_unit_ns);
     return root;
 }
 
@@ -2979,6 +3011,23 @@ static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
 }
 
 /* One container's xs:anyAttribute grammar (NULL when absent). */
+/* #1735: the target namespace of the schema unit containing +e+
+ * (the enclosing xs:schema's @targetNamespace; NULL when absent).
+ * ##targetNamespace/##other in wildcards resolve against THIS, not
+ * the merged schema's main tns — the unit boundary is where
+ * provenance is otherwise lost. */
+static char* xsd_capture_unit_tns(LeptrisElement e) {
+    for (LeptrisElement up = leptris_element_parent(e); up;
+         up = leptris_element_parent(up)) {
+        const char* local = NULL;
+        leptris_element_expanded_name(up, &local, NULL, NULL);
+        if (local && strcmp(local, "schema") == 0)
+            return xsd_strdup(leptris_element_attribute(up,
+                                                        "targetNamespace"));
+    }
+    return NULL;
+}
+
 static char* xsd_capture_any_attr_ns(LeptrisElement container) {
     for (LeptrisNodeRef ac = leptris_node_first_child(
              leptris_element_as_node(container));

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

@@ -289,7 +289,11 @@ int xsd_content_valid(struct leptris_xsd_schema* s, XsdCm* model,
                         (!p->ns || (uri && strcmp(uri, p->ns) == 0)))
                         ss_add(&next, tr->to);
                 } else if (p->kind == XSD_CM_ANY) {
-                    if (any_ns_matches(p, uri, target_ns))
+                    /* #1735: ##targetNamespace/##other are relative
+                     * to the DECLARING unit's tns */
+                    if (any_ns_matches(p, uri,
+                                       p->any_unit_tns ? p->any_unit_tns
+                                                       : target_ns))
                         ss_add(&next, tr->to);
                 }
             }

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

@@ -478,11 +478,19 @@ static void validate_attributes(struct xsd_validator* v,
         /* extension union: an attribute is allowed when it matches the
          * derived type's wildcard OR the base type's (the spec's
          * attribute-wildcard union; #1691 anyAttr-derive family) */
+        /* #1735: each wildcard resolves against its DECLARING
+         * unit's tns (recorded at capture); the merged schema's tns
+         * is the fallback */
         if ((ta->any_attr_ns &&
-             any_attr_matches(ta->any_attr_ns, auri, xsd_target_ns(s))) ||
+             any_attr_matches(ta->any_attr_ns, auri,
+                              ta->any_attr_unit_ns
+                                  ? ta->any_attr_unit_ns
+                                  : xsd_target_ns(s))) ||
             (ta->any_attr_base_ns &&
              any_attr_matches(ta->any_attr_base_ns, auri,
-                              xsd_target_ns(s))))
+                              ta->any_attr_base_unit_ns
+                                  ? ta->any_attr_base_unit_ns
+                                  : xsd_target_ns(s))))
             continue;
         verrf_at(v, elem, "attribute", local,
                  "not declared (strict)");

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

@@ -101,6 +101,10 @@ typedef struct xsd_cm {
                      * capture time (forward ref) — folded by the
                      * post-capture resolver (leptris-ruby#440 A) */
     char* any_ns; /* CM_ANY: the namespace attribute grammar */
+    /* #1735: the target namespace of the unit DECLARING the
+     * wildcard — ##targetNamespace/##other are unit-relative and
+     * the merged schema keeps only the main unit's tns */
+    char* any_unit_tns;
     int process_skip; /* CM_ANY: processContents="skip" or "lax" */
     int min, max; /* occurrence bounds; max < 0 = unbounded */
     struct xsd_cm* first_child; /* group children list */
@@ -198,6 +202,9 @@ typedef struct xsd_type_attrs {
     char* ns;           /* leptris-ruby#440: declaring schema's tns */
     char* any_attr_ns; /* xs:anyAttribute grammar (NULL = absent) */
     char* any_attr_base_ns; /* extension: the base type's wildcard (union) */
+    /* #1735: declaring unit's tns for each wildcard above */
+    char* any_attr_unit_ns;
+    char* any_attr_base_unit_ns;
     XsdAttrDecl* attrs;
     struct xsd_type_attrs* next;
 } XsdTypeAttrs;

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

@@ -2173,3 +2173,164 @@ TEST(XsdConformance, ManifestExpectationsMatchOracle) {
     RecordProperty("pass_invalid", std::to_string(pass_invalid));
     RecordProperty("pass_schema_error", std::to_string(pass_schema_error));
 }
+
+// ---- #1735: unit-relative wildcard provenance across imports ----
+// ##targetNamespace / ##other resolve against the target namespace
+// of the unit the wildcard is DECLARED in, not the merged schema's
+// main tns.
+namespace {
+
+int validate_compiled(LeptrisXsdSchema s, const char* xml) {
+    LeptrisStatus vst = LEPTRIS_OK;
+    LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &vst);
+    if (!d) return 0;
+    int ok = leptris_xsd_validate(s, d);
+    leptris_document_free(d);
+    return ok;
+}
+
+/* imp.xsd carries tns urn:imp and a type whose wildcard uses
+ * ##targetNamespace; main.xsd (tns urn:main) imports it. An
+ * instance child in urn:imp satisfies the wildcard (declaring
+ * unit's tns), one in urn:other never does. */
+TEST(XsdWildcardUnitTns1735, ElementTargetNamespaceInImportedUnit) {
+    std::string dir = ::testing::TempDir();
+    FILE* f1 = fopen((dir + "x1735imp.xsd").c_str(), "wb");
+    ASSERT_NE(f1, nullptr);
+    const char* imp =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:imp\">"
+        "<xs:complexType name=\"CT_Open\">"
+        "<xs:sequence>"
+        "<xs:any namespace=\"##targetNamespace\" processContents=\"skip\""
+        " minOccurs=\"0\" maxOccurs=\"unbounded\"/>"
+        "</xs:sequence>"
+        "</xs:complexType>"
+        "</xs:schema>";
+    fwrite(imp, 1, strlen(imp), f1);
+    fclose(f1);
+    FILE* f2 = fopen((dir + "x1735main.xsd").c_str(), "wb");
+    ASSERT_NE(f2, nullptr);
+    const char* mainx =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:i=\"urn:imp\""
+        " targetNamespace=\"urn:main\">"
+        "<xs:import namespace=\"urn:imp\""
+        " schemaLocation=\"x1735imp.xsd\"/>"
+        "<xs:element name=\"r\" type=\"i:CT_Open\"/>"
+        "</xs:schema>";
+    fwrite(mainx, 1, strlen(mainx), f2);
+    fclose(f2);
+
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile_file((dir + "x1735main.xsd").c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0) << "status " << (int)st;
+    /* child in the IMPORTED unit's tns: the wildcard's
+     * ##targetNamespace is urn:imp (the declaring unit) */
+    EXPECT_EQ(validate_compiled(s, "<r><x xmlns=\"urn:imp\"/></r>"), 1)
+        << "##targetNamespace must resolve against urn:imp";
+    /* a third namespace matches neither reading */
+    EXPECT_EQ(validate_compiled(s, "<r><x xmlns=\"urn:other\"/></r>"), 0);
+    leptris_xsd_free(s);
+    remove((dir + "x1735imp.xsd").c_str());
+    remove((dir + "x1735main.xsd").c_str());
+}
+
+/* ##other in the imported unit excludes the declaring unit's tns
+ * (urn:imp) only — the MAIN unit's tns (urn:main) is "other". */
+TEST(XsdWildcardUnitTns1735, ElementOtherInImportedUnit) {
+    std::string dir = ::testing::TempDir();
+    FILE* f1 = fopen((dir + "x1735oimp.xsd").c_str(), "wb");
+    ASSERT_NE(f1, nullptr);
+    const char* imp =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:imp\">"
+        "<xs:complexType name=\"CT_Open\">"
+        "<xs:sequence>"
+        "<xs:any namespace=\"##other\" processContents=\"skip\""
+        " minOccurs=\"0\" maxOccurs=\"unbounded\"/>"
+        "</xs:sequence>"
+        "</xs:complexType>"
+        "</xs:schema>";
+    fwrite(imp, 1, strlen(imp), f1);
+    fclose(f1);
+    FILE* f2 = fopen((dir + "x1735omain.xsd").c_str(), "wb");
+    ASSERT_NE(f2, nullptr);
+    const char* mainx =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:i=\"urn:imp\""
+        " targetNamespace=\"urn:main\">"
+        "<xs:import namespace=\"urn:imp\""
+        " schemaLocation=\"x1735oimp.xsd\"/>"
+        "<xs:element name=\"r\" type=\"i:CT_Open\"/>"
+        "</xs:schema>";
+    fwrite(mainx, 1, strlen(mainx), f2);
+    fclose(f2);
+
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile_file((dir + "x1735omain.xsd").c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0) << "status " << (int)st;
+    /* the declaring unit's own tns is what ##other excludes */
+    EXPECT_EQ(validate_compiled(s, "<r><x xmlns=\"urn:imp\"/></r>"), 0);
+    /* the main unit's tns is OTHER relative to urn:imp */
+    EXPECT_EQ(validate_compiled(s, "<r><x xmlns=\"urn:main\"/></r>"), 1)
+        << "##other is relative to urn:imp, not the main tns";
+    leptris_xsd_free(s);
+    remove((dir + "x1735oimp.xsd").c_str());
+    remove((dir + "x1735omain.xsd").c_str());
+}
+
+/* attribute wildcards carry the same unit-relative provenance */
+TEST(XsdWildcardUnitTns1735, AnyAttrTargetNamespaceInImportedUnit) {
+    std::string dir = ::testing::TempDir();
+    FILE* f1 = fopen((dir + "x1735aimp.xsd").c_str(), "wb");
+    ASSERT_NE(f1, nullptr);
+    const char* imp =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:imp\">"
+        "<xs:complexType name=\"CT_Open\">"
+        "<xs:sequence>"
+        "<xs:element name=\"a\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "<xs:anyAttribute namespace=\"##targetNamespace\""
+        " processContents=\"skip\"/>"
+        "</xs:complexType>"
+        "</xs:schema>";
+    fwrite(imp, 1, strlen(imp), f1);
+    fclose(f1);
+    FILE* f2 = fopen((dir + "x1735amain.xsd").c_str(), "wb");
+    ASSERT_NE(f2, nullptr);
+    const char* mainx =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:i=\"urn:imp\""
+        " targetNamespace=\"urn:main\">"
+        "<xs:import namespace=\"urn:imp\""
+        " schemaLocation=\"x1735aimp.xsd\"/>"
+        "<xs:element name=\"r\" type=\"i:CT_Open\"/>"
+        "</xs:schema>";
+    fwrite(mainx, 1, strlen(mainx), f2);
+    fclose(f2);
+
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile_file((dir + "x1735amain.xsd").c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0) << "status " << (int)st;
+    /* the extra attribute lives in urn:imp = the declaring unit's
+     * ##targetNamespace */
+    EXPECT_EQ(validate_compiled(
+                  s, "<r xmlns:x=\"urn:imp\" x:note=\"hi\"><a>x</a></r>"),
+              1)
+        << "anyAttribute ##targetNamespace must resolve against urn:imp";
+    /* a foreign-namespace attribute never matches */
+    EXPECT_EQ(validate_compiled(
+                  s,
+                  "<r xmlns:y=\"urn:other\" y:note=\"hi\"><a>x</a></r>"),
+              0);
+    leptris_xsd_free(s);
+    remove((dir + "x1735aimp.xsd").c_str());
+    remove((dir + "x1735amain.xsd").c_str());
+}
+
+}  // 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.361",
+  "version": "1.9.362",
   "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.361.1
+  version: 1.9.362.1
 platform: aarch64-linux
 authors:
 - Ribose Inc.