leptris 1.9.362.1-arm-linux → 1.9.363.1-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d505c20eccb4e2b386fb97b23352696c4cf4a09b65beb33173fe4f56e5acb76e
-  data.tar.gz: 9065bccde783c51f95fad5d08d4eda84450393e345f1c307b588df7fae99c356
+  metadata.gz: 925490d2b1768ed2ab9f27b1182011550c696601b8f36b129bdf427acaa51a76
+  data.tar.gz: 967796e1f35ea9636bf43f49ad6f73970df0dc8b161cf75aab57b165f08a8e79
 SHA512:
-  metadata.gz: 4e4762693d0c5907d70d15d532ad55681718db89157e743907dd330c6639cb2ed3d4eee91540d5e3e7b5a3e7793bdb00020bce8511335f3b9224af46128e7d4c
-  data.tar.gz: a9a84e6b9aaba30c5c7b3a232268baf149127207d12e159427d426daf4829d8bc378d20efe97045cc3eda070950aaf5526f23eb389c7686e805d333bedd9c95b
+  metadata.gz: 42b43e2760a56807be81cc0c0fa02617b4ade4dbfceab4e0291c1fcf1cd90e7d583ff82ca32c54eabb998f07ec8aad7f5798881cd46225b7f7d9f224a9a5e720
+  data.tar.gz: 252d2b9d79379509c5dde2ab5d8eb5e0bb30678838e95b2466c4c4a2b1a1b083f41576244894e6f0e8b7bbd0bda92fc28c9587b217904a0ba2adc05e94939426

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.362"
+LIBLEPTRIS_VERSION = "1.9.363"
 # 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.362.1"
+  VERSION = "1.9.363.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.362
+- libleptris v1.9.363
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [1.9.363] - 2026-10-16
+
+### Fixed
+
+- **parse: RECOVER folds a bare `<` in text into the run (#1748, PR #1750).**
+  `< b` — a `<` that opens no markup construct — had no recovery lane: even
+  under `LEPTRIS_PARSE_RECOVER` the parse aborted to the #547 empty-document
+  fallback with the diagnostic list EMPTY. Silent total data loss on
+  `<script>if (a < b) { c(); }</script>` (the shape HTML-producing tools
+  emit), and the missing record kept recovery-record-keyed consumers —
+  canon's loud/tolerant HTML fallback — from ever engaging, so the input
+  serialized as just the XML declaration. The text scan now folds the byte
+  into the run with a `LEPTRIS_DIAG_RECOVER` record under RECOVER (libxml2
+  keeps the full tree and reports 5 errors on the reporter's input; ours
+  now keeps the tree too); strict parsing still fails. Engine suite
+  2046/2046; canon's battery spec goes 1 failure → 0.
+
+
 ## [1.9.362] - 2026-10-16
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/leptris/flat/direct_parse.c

@@ -1729,7 +1729,7 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                     : ((p.end - q > 48) ? q + 48 : p.end);
                 while (q < probe_end) {
                     char ch = *q;
-                    if (ch == '<') { lt = (char*)q; goto text_done; }
+                    if (ch == '<') { lt = (char*)q; break; }
                     has_amp |= (ch == '&');
                     has_cr |= (ch == '\r');
                     q++;
@@ -1740,6 +1740,33 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                 has_amp |= memchr(q, '&', (size_t)((char*)lt - q)) != NULL;
                 has_cr |= memchr(q, '\r', (size_t)((char*)lt - q)) != NULL;
             }
+            /* leptris#1748: a '<' that opens no markup construct
+             * ('!', '?', '/', name-start) is unescaped text. Strict
+             * keeps failing at it; RECOVER records a diagnostic and
+             * folds the byte into the text run (libxml2
+             * XML_PARSE_RECOVER semantics) — previously this class
+             * aborted to the empty-document fallback with NO tree
+             * and NO diagnostic (the silent corruption canon hit). */
+            while (lt && lt + 1 < p.end && p.recover) {
+                char nx = lt[1];
+                if (nx == '!' || nx == '?' || nx == '/' ||
+                    IS_NAME_START(nx))
+                    break;
+                leptris_diag_emit(
+                    &p.doc->parse_diags, &p.doc->parse_diag_count,
+                    &p.doc->parse_diag_cap,
+                    LEPTRIS_DIAG_RECOVER, NULL,
+                    "Unescaped < not allowed in a text node");
+                const char* nq = lt + 1;
+                const char* nlt =
+                    memchr(nq, '<', (size_t)(p.end - nq));
+                const char* span_end = nlt ? nlt : p.end;
+                has_amp |= memchr(nq, '&',
+                                  (size_t)(span_end - nq)) != NULL;
+                has_cr |= memchr(nq, '\r',
+                                 (size_t)(span_end - nq)) != NULL;
+                lt = (char*)nlt;
+            }
         text_done:
             p.pos = lt ? lt : p.end;
             size_t tlen = p.pos - text_start;

data/vendor-src/libleptris/test/parser/test_parser.cpp

@@ -838,6 +838,68 @@ TEST(ParseRecover, UnclosedAtEofClosesEverything) {
     leptris_document_free(doc);
 }
 
+/* leptris#1748: a bare '<' followed by a non-markup character
+ * ('< b') is unescaped text. RECOVER folds the byte into the text
+ * run (libxml2 XML_PARSE_RECOVER semantics) and records a
+ * diagnostic; the script-with-comparison shape previously aborted
+ * to the empty-document fallback SILENTLY — no tree, no diagnostic
+ * — which blinded every consumer keyed on the record. */
+TEST(ParseRecover, BareLtInTextKeepsTreeAndRecords) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char xml[] =
+        "<root><script>if (a < b) { c(); }</script></root>";
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_RECOVER, &st);
+    ASSERT_NE(doc, nullptr) << "status " << (int)st;
+    LeptrisElement root = leptris_document_root(doc);
+    ASSERT_NE(root, nullptr);
+    EXPECT_STREQ(leptris_element_name(root), "root");
+    LeptrisElement script = leptris_element_first_child_any(root);
+    ASSERT_NE(script, nullptr);
+    EXPECT_STREQ(leptris_element_name(script), "script");
+    /* The unescaped byte rides the text verbatim (libxml2 keeps the
+     * run as one node; ours may split — content is the contract). */
+    const char* text = leptris_element_text(script);
+    ASSERT_NE(text, nullptr);
+    EXPECT_STREQ(text, "if (a < b) { c(); }");
+    EXPECT_EQ(leptris_document_parse_diag_count(doc), 1u);
+    LeptrisDiagKind kind = (LeptrisDiagKind)-1;
+    char msg[128] = {0};
+    ASSERT_EQ(leptris_document_parse_diag(doc, 0, &kind, msg,
+                                          sizeof(msg)), 1);
+    EXPECT_EQ(kind, LEPTRIS_DIAG_RECOVER);
+    leptris_document_free(doc);
+}
+
+TEST(ParseRecover, BareLtInTextStrictStillFails) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char xml[] =
+        "<root><script>if (a < b) { c(); }</script></root>";
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_DEFAULT, &st);
+    EXPECT_EQ(doc, nullptr);
+    EXPECT_EQ(st, LEPTRIS_ERROR_PARSE);
+}
+
+/* The #1748 reporter shape end-to-end: DOCTYPE-prefixed HTML-
+ * shaped input through the XML lane keeps the whole tree. */
+TEST(ParseRecover, DoctypePrefixedHtmlShapeKeepsTree) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char xml[] =
+        "<!DOCTYPE html>\n<html><head><meta charset=\"utf-8\">"
+        "<title>t</title></head>\n"
+        "<body><p>hello<br>world<img src=\"x.png\"><ul><li>one<li>two</ul>\n"
+        "<script>if (a < b) { c(); }</script></body></html>";
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_RECOVER, &st);
+    ASSERT_NE(doc, nullptr) << "status " << (int)st;
+    LeptrisElement root = leptris_document_root(doc);
+    ASSERT_NE(root, nullptr);
+    EXPECT_STREQ(leptris_element_name(root), "html");
+    EXPECT_GT(leptris_document_parse_diag_count(doc), 0u);
+    leptris_document_free(doc);
+}
+
 TEST(ParseRecover, WithoutFlagStillFails) {
     LeptrisStatus st = LEPTRIS_OK;
     const char xml[] = "<root><a>x</b></root>";

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.362",
+  "version": "1.9.363",
   "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.362.1
+  version: 1.9.363.1
 platform: arm-linux
 authors:
 - Ribose Inc.