leptris 1.9.319.0-ppc64le-linux → 1.9.321.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ee497bb903d46114b37f9f792a4777b341e8979d5588a04a21f67e54ae7e6ca
-  data.tar.gz: 248491ca63975b2ecfb2e1b558a098b6f58d8a6c4db487ac7a2b4a40829a58d9
+  metadata.gz: c1048f2fc1a458e50488f4a53446f240132e308854082ef6111ca9efeb1a9689
+  data.tar.gz: 354c7562a80d80c4ab7b61bd0289cae6df4d06153b17ba63386c9a03b135f71a
 SHA512:
-  metadata.gz: 22969ea6a40c82c0b83fcd05d94ebd8fbf08b5e5ebc3f49a4f7252eb428692d4c9bea982ba72a884561713f1854b92a4d9e10c0ae111e4939e6ded546d4e8ceb
-  data.tar.gz: 1606e4a9131361bd12a52fdc947f3fc59e0389121a21189370eb813c725491a7f25caa7e0929e060785c374793eea06a55b87290141803bfbe6a4bb92fc9e6f2
+  metadata.gz: 17327bf2ee904eb779ffdcc430cfd6d2efd44a597e0bde5c223cef1f158372fed36cf61ce3f0d02fd16e14f822b9646d01719cc893e7ec8d9f93d0de39758281
+  data.tar.gz: 0b6affc78a6e658809641bedea21c45886558d50f662a35a1c42698512617a7cf5fbdcfc650054dc6d27b4855536a1281ac9651a653c2f55e0f52a34bb67b8e7

data/CHANGELOG.md

@@ -1,3 +1,38 @@
+## [1.9.321.0] - 2026-10-08
+
+### Added — engine sync (libleptris 1.9.321)
+
+- **XSD instance validation, slices 3-4 (#1075)**:
+  `Schema#valid?` walks the whole document — element declarations,
+  attribute rows (required + typed + lenient qualified spellings),
+  text lexical checks, child content models through a Thompson NFA
+  (linear in children x states, no backtracking blowup);
+  `Schema#validate_errors` enumerates every failure (the engine
+  replaces the list per run); `Schema#content_valid?` evaluates a
+  child sequence directly against a top-level declaration's model.
+  The -1 contract raises (unknown declaration never masquerades as
+  invalid input). Pins use the named-ref shape — the inline-
+  anonymous complexType capture gap is filed upstream
+  (leptris#1592).
+
+## [1.9.320.0] - 2026-10-08
+
+### Fixed — engine sync (libleptris 1.9.320)
+
+- **Exact-URI child rows survive build-anchor GC (#1585)**: the
+  engine's plan build let child-row `ns_uri` ride a pointer into
+  the caller's build buffers instead of deep-copying — bindings
+  GC their anchors after build, so exact-URI child rows
+  deterministically stopped matching (uniword's
+  dc:title/dc:creator/dc:description hydrated nil). The engine
+  retains the URI; pinned with build + GC + walk.
+- **Plain attribute rows match any qualification (#1586)**:
+  ns-unset attr rows try the exact wire spelling first, then any
+  qualification by local name (#758 parity) — plain rows bind
+  `w:name`/`w:val` exactly as the interpretive path does, top
+  level and nested; exact-URI rows keep their #1486 precedence.
+  Pinned at both depths.
+
 ## [1.9.319.0] - 2026-10-08
 
 ### Added — engine sync (libleptris 1.9.319)

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.319"
+LIBLEPTRIS_VERSION = "1.9.321"
 # 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.319.0"
+  VERSION = "1.9.321.0"
 end

data/lib/leptris/xml/ffi.rb

@@ -1304,6 +1304,21 @@ attach_function :leptris_parse_string,
         [:string, :string], :int
       attach_function :leptris_xsd_simple_valid,
         [:leptris_xsd_schema, :string, :string], :int
+      # Slices 3-4 (libleptris 1.9.321, #1075): content models via
+      # Thompson NFA (linear in children x states) and whole-
+      # instance validation — element declarations, attribute rows
+      # (required + typed + lenient qualified spellings), text
+      # lexical checks, child content models. Failures enumerate
+      # behind error_count/_at (schema-owned; the next validate
+      # run replaces them).
+      attach_function :leptris_xsd_content_valid,
+        [:leptris_xsd_schema, :string, :pointer, :pointer, :size_t], :int
+      attach_function :leptris_xsd_validate,
+        [:leptris_xsd_schema, :leptris_document], :int
+      attach_function :leptris_xsd_error_count,
+        [:leptris_xsd_schema], :size_t
+      attach_function :leptris_xsd_error_at,
+        [:leptris_xsd_schema, :size_t], UTF8_STRING
 
       attach_function :leptris_rng_parse,
         [:string, :size_t, :pointer], :leptris_relaxng

data/lib/leptris/xml/xsd.rb

@@ -79,14 +79,66 @@ module Leptris::XML::XSD
     # name) — restriction chains validate every hop's facets,
     # cycle-guarded. Unknown type names raise (the -1 contract).
     def simple_valid?(type_name, lexical)
-      r = Leptris::XML::FFI.leptris_xsd_simple_valid(
-        @handle, type_name.to_s, lexical.to_s)
-      case r
+      tri_state(
+        Leptris::XML::FFI.leptris_xsd_simple_valid(
+          @handle, type_name.to_s, lexical.to_s),
+        "#{type_name.inspect} is not a simpleType in this schema")
+    end
+
+    # Slices 3-4 (libleptris 1.9.321, #1075): whole-instance
+    # validation — element declarations, attribute rows (required
+    # + typed + lenient qualified spellings), text lexical checks,
+    # and child content models through the Thompson NFA. Returns
+    # true/false.
+    def valid?(document)
+      tri_state(
+        Leptris::XML::FFI.leptris_xsd_validate(
+          @handle, document.c_ptr), "invalid document handle")
+    end
+
+    # The enumerated failure list of the last #validate run
+    # (empty when valid; the NEXT validate replaces the list).
+    def validate_errors(document)
+      valid?(document)
+      Leptris::XML::FFI.leptris_xsd_error_count(@handle).times.map do |i|
+        Leptris::XML::FFI.leptris_xsd_error_at(@handle, i)
+      end
+    end
+
+    # Slice 3 direct face: a child SEQUENCE against a top-level
+    # element declaration's compiled content model (occurrence
+    # bounds, xs:any wildcards). +children+ are child Nodes (name
+    # + effective namespace extracted per child). Unknown element
+    # declarations raise (the -1 contract).
+    def content_valid?(element_name, children)
+      kids = children.to_a
+      nb, na = Leptris::XML::CStringArray.to_c(
+        kids.map { |c| c.name.to_s })
+      ub, ua = Leptris::XML::CStringArray.to_c(
+        kids.map { |c| child_ns_uri(c) })
+      tri_state(
+        Leptris::XML::FFI.leptris_xsd_content_valid(
+          @handle, element_name.to_s, nb, ub, kids.size),
+        "#{element_name.inspect} is not a top-level element declaration")
+    end
+
+    private
+
+    # A child's effective namespace URI (nil = none) — read
+    # through its own c_ptr, so docless wrappers work.
+    def child_ns_uri(node)
+      uri = Leptris::XML::FFI.leptris_element_namespace(node.c_ptr)
+      uri.nil? || uri.empty? ? "" : uri
+    end
+
+    # The C faces' 1/0/-1 contract: true/false, with -1 raising —
+    # a silent false would mean "no such declaration/type", which
+    # callers must never confuse with "invalid input".
+    def tri_state(code, unknown_message)
+      case code
       when 1 then true
       when 0 then false
-      else
-        raise ArgumentError,
-          "#{type_name.inspect} is not a simpleType in this schema"
+      else raise ArgumentError, unknown_message
       end
     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.319
+- libleptris v1.9.321
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,50 @@
 ## [Unreleased]
 
+## [1.9.321] - 2026-10-08
+
+### Added
+
+- **XSD validation, tier 1, slices 3–4 (#1075, PRs #1589/#1590).**
+  Slice 3 — content models: the compiler captures top-level
+  `xs:element` declarations and named `xs:complexType` models
+  (sequence/choice/all, occurrence bounds incl. unbounded, element
+  name/ref particles, `xs:any` wildcards with the full
+  namespace-filter grammar); `leptris_xsd_content_valid` evaluates
+  a child sequence through a Thompson NFA — linear in children x
+  states, no backtracking blowup on nested choices. Slice 4 —
+  instance validation: `leptris_xsd_validate(schema, document)`
+  walks element declarations, complexType attribute rows
+  (required + typed + lenient qualified spellings), child content
+  models, and lexical text checks for simple-typed elements
+  (particles carry type refs); failures enumerate behind
+  `leptris_xsd_error_count/_at`. The libxml2 corpus gate holds at
+  163/163; full suite 1911/1911.
+
+
+
+## [1.9.320] - 2026-10-08
+
+### Fixed
+
+- **Descriptor: child-row exact-URI `ns_uri` retained at build
+  (#1585, PR #1587).** The build deep-copied child `ns_prefix` but
+  let `ns_uri` ride the struct copy — a pointer into the caller's
+  build buffers. Bindings GC their anchors (a warm walk plus one GC
+  makes it deterministic), after which exact-URI child rows
+  silently stopped matching and hydration answered nil (uniword's
+  `dc:title`/`dc:creator`/`dc:description`). The spec trashes the
+  caller's buffer after build and asserts the row still binds.
+- **Descriptor: plain attribute rows match any qualification
+  (#1586, PR #1587).** `dp_attr_value`'s ns-unset path now mirrors
+  #758 — the exact wire spelling first, then any qualification by
+  local name — so plain rows bind `w:name`/`w:val` exactly as the
+  interpretive path does, top level and nested. Exact-URI rows keep
+  their #1486 precedence. A NESTED row's binding also consults the
+  TARGET plan's `ns_lenient` now (the #1115-consistent authority)
+  instead of the outer plan's.
+
+
+
 ## [1.9.319] - 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.319
+    VERSION 1.9.321
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/src/CMakeLists.txt

@@ -29,6 +29,8 @@ set(LEPTRIS_SOURCES
     leptris/rng/parse.c
     leptris/xsd/compile.c
     leptris/xsd/datatypes.c
+    leptris/xsd/content_model.c
+    leptris/xsd/validate.c
     leptris/rng/rng_public.c
     leptris/rng/rng_regex.c
     leptris/rng/validate.c

data/vendor-src/libleptris/src/include/leptris.h

@@ -920,6 +920,28 @@ LEPTRIS_API int leptris_xsd_builtin_valid(const char* builtin,
 LEPTRIS_API int leptris_xsd_simple_valid(LeptrisXsdSchema schema,
                                          const char* type_name,
                                          const char* lexical);
+/* Slice 3 — content models. Validates a child sequence against the
+ * compiled content model of a top-level element declaration (its
+ * type's sequence/choice/all with occurrence bounds and xs:any
+ * wildcards). 1 valid, 0 invalid, -1 unknown element. child_ns may
+ * be NULL (all children unqualified). */
+LEPTRIS_API int leptris_xsd_content_valid(
+    LeptrisXsdSchema schema, const char* element_name,
+    const char* const* child_names, const char* const* child_ns,
+    size_t child_count);
+/* Slice 4 — instance validation. Walks the document against the
+ * compiled schema: element declarations by name, attribute rows
+ * (required use + typed values, lenient qualified spellings),
+ * text lexical checks for simple-typed elements, child content
+ * models (slice 3). Returns 1 valid, 0 invalid, -1 bad args.
+ * Errors accumulate — leptris_xsd_error_count/_at enumerate them
+ * (schema-owned; the next validate run replaces them; freed with
+ * the schema). */
+LEPTRIS_API int leptris_xsd_validate(LeptrisXsdSchema schema,
+                                     LeptrisDocument doc);
+LEPTRIS_API size_t leptris_xsd_error_count(LeptrisXsdSchema schema);
+LEPTRIS_API const char* leptris_xsd_error_at(LeptrisXsdSchema schema,
+                                             size_t i);
 /* Validate an instance document against the parsed schema
  * (phase-2 core subset: element/attribute/text/data/value/
  * choice/group/interleave/repeats/ref). Returns 1 valid; on 0,

data/vendor-src/libleptris/src/leptris/descriptor/plan.c

@@ -285,6 +285,7 @@ static void dp_plan_free(LeptrisPlan p) {
         for (uint32_t c = 0; c < d->child_count; c++) {
             free((char *)d->child_plans[c].wire_name);
             free((char *)d->child_plans[c].ns_prefix);
+            free((char *)d->child_plans[c].ns_uri);
             for (uint16_t pi = 0;
                  pi < d->child_plans[c].predicate_count; pi++) {
                 free((char*)d->child_plans[c]
@@ -481,6 +482,15 @@ LEPTRIS_API LeptrisPlan leptris_plan_build(const leptris_plan_spec* spec,
                     sc->ns_prefix ? dp_strdup(sc->ns_prefix) : NULL;
                 if (sc->ns_prefix && !d->child_plans[c].ns_prefix)
                     goto oom;
+                /* #1585: ns_uri rides the struct copy otherwise —
+                 * a dangling pointer into the caller's build
+                 * buffers once they are reclaimed (bindings GC
+                 * their anchors; the descriptor must outlive
+                 * them). Same retention as attr rows (#1486). */
+                d->child_plans[c].ns_uri =
+                    sc->ns_uri ? dp_strdup(sc->ns_uri) : NULL;
+                if (sc->ns_uri && !d->child_plans[c].ns_uri)
+                    goto oom;
                 uint16_t pc = sc->predicate_count;
                 if (pc) {
                     if (!sc->predicates) goto oom;
@@ -598,8 +608,25 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
  * namespace (XML namespaces §5.2) — EXACT never binds them. */
 static const char* dp_attr_value(LeptrisElement elem,
                                  const leptris_attr_plan* ap) {
-    if (!ap->ns_form)
-        return leptris_element_attribute(elem, ap->wire_name);
+    if (!ap->ns_form) {
+        /* #1586, the plan-path mirror of #758: the exact wire
+         * spelling first, then any qualification by local name —
+         * plain rows are lenient exactly like element rows under
+         * ns_lenient. Exact-URI rows keep their #1486 semantics. */
+        const char* exact =
+            leptris_element_attribute(elem, ap->wire_name);
+        if (exact) return exact;
+        for (LeptrisAttribute at = leptris_element_first_attribute(elem);
+             at; at = leptris_attribute_next(at)) {
+            const char* qn = leptris_attribute_get_name(at);
+            if (!qn) continue;
+            const char* colon = strchr(qn, ':');
+            const char* local = colon ? colon + 1 : qn;
+            if (strcmp(local, ap->wire_name) == 0)
+                return leptris_attribute_get_value(elem, at);
+        }
+        return NULL;
+    }
     for (LeptrisAttribute at = leptris_element_first_attribute(elem);
          at; at = leptris_attribute_next(at)) {
         const char* qn = leptris_attribute_get_name(at);
@@ -832,8 +859,13 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
                 LeptrisElement child = (LeptrisElement)n;
                 if (!dp_wire_name_matches(child, row->wire_name))
                     continue;
+                /* The TARGET plan's form governs (#1115) — so its
+                 * lenient flag governs the leniency, not the outer
+                 * plan's (#1586: a namespaced child under a plan
+                 * that declares ns_lenient binds by local name). */
                 if (!dp_ns_binds(child, target->ns_form, target->ns_uri,
-                                 lenient))
+                                 (target->flags &
+                                  LEPTRIS_PLAN_FLAG_NS_LENIENT) != 0))
                     continue;
                 /* Claim the element against later same-wire rows
                  * (predicate partitioning). */