leptris 1.9.320.0-ppc64le-linux → 1.9.322.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7691bd3eb83cab9783c2a73c4a42e9dc2ac129b13d40342f46a7bc9609b8e902
-  data.tar.gz: b1d4348cd9fd819a7cd808c33d8c1204261e6f4472327c76f0f6f4017d233ae3
+  metadata.gz: 7f838f3aa92b2932ec3b32f7cf4227c70c415a84c5916f115f4f1b6811c2a913
+  data.tar.gz: fed0ebac144489410e7737113f5f0210e652113d9921cab7422fdbf182ec91e0
 SHA512:
-  metadata.gz: 2a7312c3e914fbb020c54c0c80ee11e4ebee98b26b4bd15fa7e8f3f4e85cb54827adfa3664fe39ac541d3c9ecc2652aa80488c0d87acd2174e27e911d3794525
-  data.tar.gz: c11f2d4c3910a6be2f7945ceb0e30fc14339cdae47b74e10b31058b28983a4caca94efd3da0140ecbb9a22875764f15544eefe7a6917066f0b25599f06c69b53
+  metadata.gz: 4f65c9924ed95bd9cc2e577982bc99d5508a89c0f5cdaa272224b5ce36973b88d2c5fd4c2e486f70e33a140fc74c57a1fbdb13f764a790044952d889c7f337ef
+  data.tar.gz: 27b270be847e3dde7c1806030f654ff0766695437ca1b32b5a5e910728f38aa1a52ecd6d65b85955f3df7aa24d9e6d67243501e5b2294b56845a58fb0e22b5e0

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## [1.9.322.0] - 2026-10-08
+
+### Engine sync (libleptris 1.9.322)
+
+- `leptris validate --xsd FILE` rides the CLI's validate command
+  (compile error detail, every accumulated instance error,
+  non-zero exit) — CLI-only, no binding surface; audit 381/380
+  unchanged. The inline-anonymous complexType capture fix
+  (leptris#1592, engine PR #1596) merged after this tag and ships
+  with the engine's next release — the binding pin follows there.
+
+## [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)

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.320"
+LIBLEPTRIS_VERSION = "1.9.322"
 # 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.320.0"
+  VERSION = "1.9.322.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.320
+- libleptris v1.9.322
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,40 @@
 ## [Unreleased]
 
+## [1.9.322] - 2026-10-08
+
+### Added
+
+- **`leptris validate --xsd FILE` (#1075, PR #1593).** The compiled
+  XSD surface rides the same validate command as `--dtd`/`--rng`/
+  `--schematron`: compile failures report the schema's own error
+  detail (compile returns error-carrying handles — the status keys
+  the failure); invalid documents print every accumulated error and
+  exit non-zero.
+
+
+
+## [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

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/cli/commands/validate.c

@@ -156,6 +156,7 @@ static int run_schematron(const char* path, const char* phase,
 
 static cli_result_t validate_execute(int argc, char** argv) {
     const char* rng_path = NULL;
+    const char* xsd_path = NULL;
     const char* sch_path = NULL;
     const char* dtd_path = NULL;
     const char* phase = NULL;
@@ -164,6 +165,8 @@ static cli_result_t validate_execute(int argc, char** argv) {
     for (int i = 1; i < argc; i++) {
         if (strcmp(argv[i], "--rng") == 0 && i + 1 < argc) {
             rng_path = argv[++i];
+        } else if (strcmp(argv[i], "--xsd") == 0 && i + 1 < argc) {
+            xsd_path = argv[++i];
         } else if ((strcmp(argv[i], "--schematron") == 0 ||
                     strcmp(argv[i], "-s") == 0) &&
                    i + 1 < argc) {
@@ -184,6 +187,7 @@ static cli_result_t validate_execute(int argc, char** argv) {
             printf("Options:\n");
             printf("  --dtd FILE          External DTD\n");
             printf("  --rng FILE          RELAX NG schema\n");
+            printf("  --xsd FILE          W3C XML Schema (XSD)\n");
             printf("  --schematron FILE   ISO Schematron schema\n");
             printf("  --phase ID          Schematron phase to");
             printf(" select\n");
@@ -205,8 +209,8 @@ static cli_result_t validate_execute(int argc, char** argv) {
         cli_error("validate requires an XML document");
         return CLI_ERROR_ARGS;
     }
-    if (!rng_path && !sch_path && !dtd_path) {
-        cli_error("validate needs --dtd and/or --rng and/or --schematron");
+    if (!rng_path && !sch_path && !dtd_path && !xsd_path) {
+        cli_error("validate needs --dtd/--rng/--schematron/--xsd");
         return CLI_ERROR_ARGS;
     }
     LeptrisDocument doc = read_doc(xml_path);
@@ -261,6 +265,43 @@ static cli_result_t validate_execute(int argc, char** argv) {
         }
         leptris_rng_free(rng);
     }
+    if (xsd_path) {
+        size_t xsd_len = 0;
+        char* xsd_content = read_file(xsd_path, &xsd_len);
+        if (!xsd_content) {
+            cli_error("cannot read XSD: %s", xsd_path);
+            leptris_document_free(doc);
+            return CLI_ERROR_IO;
+        }
+        LeptrisStatus st = LEPTRIS_OK;
+        LeptrisXsdSchema xsd =
+            leptris_xsd_compile(xsd_content, xsd_len, &st);
+        free(xsd_content);
+        /* compile returns an error-carrying handle on failure — the
+         * status, not the pointer, says whether it succeeded. */
+        if (st != LEPTRIS_OK) {
+            const char* detail =
+                xsd ? leptris_xsd_error(xsd)
+                    : leptris_status_string(st);
+            cli_error("XSD compile failed: %s",
+                      detail ? detail : leptris_status_string(st));
+            if (xsd) leptris_xsd_free(xsd);
+            leptris_document_free(doc);
+            return CLI_ERROR_IO;
+        }
+        if (leptris_xsd_validate(xsd, doc)) {
+            printf("xsd: valid\n");
+        } else {
+            printf("xsd: invalid\n");
+            size_t n = leptris_xsd_error_count(xsd);
+            for (size_t i = 0; i < n; i++) {
+                const char* e = leptris_xsd_error_at(xsd, i);
+                if (e) printf("  %s\n", e);
+            }
+            invalid = 1;
+        }
+        leptris_xsd_free(xsd);
+    }
     if (sch_path) {
         cli_result_t r = run_schematron(
             sch_path, phase, want_svrl, doc, &invalid);
@@ -276,7 +317,8 @@ static cli_result_t validate_execute(int argc, char** argv) {
 
 static cli_command_t validate_command = {
     .name = "validate",
-    .description = "Validate XML against RELAX NG / Schematron",
+    .description =
+        "Validate XML against RELAX NG / Schematron / XSD",
     .execute = validate_execute,
     .print_help = NULL
 };

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,