leptris 1.9.364.1-aarch64-linux → 1.9.365.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be9630b0b1d264a6ee32c6ab3babcfb54657ed868a483b70dc88c576831c5e64
-  data.tar.gz: 454d31c45ee453cbaf61a2e24473f37256219781e00471a3cd4d18409d6b41a5
+  metadata.gz: '09191b1d6e47cb07f20ee17bca8e1dc83969f96f19b92ea218baa1e2957c619d'
+  data.tar.gz: 293dddc9db111199bb43df0d66243bc059a83ac5c8f0f21c9a8eca819352fcb1
 SHA512:
-  metadata.gz: eb24c7797b4710ece57f2274ecd04a51fd6e14829a43f04240a4d3b30d9744ce2bb61a353546c2ee4cd314a66562093b4cd11a9e5bcb1234ac9931a3e0726559
-  data.tar.gz: a2b8d0174b7101a2f35104f09d2a2928a3ee59a10449905033cfcc7ebf5453c67c43d598b9152ab4de1da20face8c1e4356a1021a303242d514ceeeb47dd8e54
+  metadata.gz: 69c108f41af0596b6988d121afeaa92c867d9c6c5e8a3905f2b18bacb6a0866e83bd8b9e48950b822d0a9da64d624927653f6ad1616393c387e9a59f3df74c10
+  data.tar.gz: bdfb75ee4ec215661ebda9e71afeee737bb6fe2216fc9495469f2baf70d41bf4eec77eacb5f32ffa8c84ecfb76ca34ba15445b0b862d4fce1b806a206923edb6

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.363"
+LIBLEPTRIS_VERSION = "1.9.365"
 # 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.364.1"
+  VERSION = "1.9.365.1"
 end

data/lib/leptris/xml/document.rb

@@ -864,6 +864,16 @@ class Leptris::XML::Document
     node
   end
 
+  # #1749: engine diag kind -> SyntaxError severity. FATAL = the
+  # classes the strict lane raises on (element still open at EOF;
+  # unescaped '<' in text, engine >= 1.9.364); the recover-class
+  # records (stray close dropped/implicit close, duplicate attribute,
+  # ...) and any future kind read :recoverable.
+  DIAG_SEVERITY = {
+    Leptris::XML::FFI::DIAG_KIND_UNCLOSED_ELEMENT => :fatal,
+    Leptris::XML::FFI::DIAG_KIND_UNESCAPED_LT => :fatal
+  }.freeze
+
   # Recovered-parse diagnostics (leptris-ruby#465): nokogiri parity
   # for the recover lane — the engine's parse diagnostics as
   # SyntaxError entries, empty for a clean parse. The engine
@@ -878,7 +888,9 @@ class Leptris::XML::Document
       ok = Leptris::XML::FFI.leptris_document_parse_diag(
         c_ptr, i, kind_buf, msg_buf, 512)
       next nil if ok.zero?
-      Leptris::XML::SyntaxError.new(msg_buf.read_string.force_encoding(Encoding::UTF_8))
+      Leptris::XML::SyntaxError.new(
+        msg_buf.read_string.force_encoding(Encoding::UTF_8),
+        severity: DIAG_SEVERITY.fetch(kind_buf.read_int, :recoverable))
     end.compact
   end
 

data/lib/leptris/xml/ffi.rb

@@ -1520,6 +1520,13 @@ attach_function :leptris_parse_string,
         [:leptris_document], :leptris_status
       attach_function :leptris_document_remove_doctype,
         [:leptris_document], :leptris_status
+      # LeptrisDiagKind (engine types.h, append-only): the values the
+      # DOM parse channel records. Document#errors maps these to
+      # SyntaxError severity (#1749) — FATAL kinds are the classes the
+      # strict lane raises on; everything else reads :recoverable.
+      DIAG_KIND_UNCLOSED_ELEMENT = 11
+      DIAG_KIND_UNESCAPED_LT = 12 # engine >= 1.9.364 (#1748/#1749)
+
       attach_function :leptris_document_parse_diag_count,
         [:leptris_document], :size_t
       attach_function :leptris_document_parse_diag,

data/lib/leptris/xml.rb

@@ -111,14 +111,22 @@ module Leptris
     # SyntaxError shape — a message plus optional position — served
     # by Document#errors.
     class SyntaxError < Error
-      attr_reader :message, :line, :column
+      attr_reader :message, :line, :column, :severity
 
-      def initialize(message, line: nil, column: nil)
+      # severity: :fatal (the strict lane raises on this class) or
+      # :recoverable (leptris-ruby#1749) — raise-on-fatal /
+      # recover-on-recoverable without string matching.
+      def initialize(message, line: nil, column: nil, severity: :recoverable)
         @message = message
         @line = line
         @column = column
+        @severity = severity
         super(message)
       end
+
+      def fatal?
+        @severity == :fatal
+      end
     end
     class ReadOnlyError < Error; end
     class XPathError < Error; 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.363
+- libleptris v1.9.365
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,39 @@
 ## [Unreleased]
 
+## [1.9.365] - 2026-10-16
+
+### Fixed
+
+- **html4: skip the XML-declaration construct in HTML input (#1748, PR #1754).**
+  The html4 lane parsed `<?xml ...?>` as a PI node (target `xml`) whose data
+  carried the terminator `?`, so serialization emitted
+  `<?xml version="1.0" encoding="UTF-8"??>` — and with the serializer's
+  `xml_declaration` riding along (the default `to_xml`), the output carried
+  two declarations, which canon's XHTML pretty-printer degenerated to
+  declaration-only output downstream. libxml2's HTML parser skips the
+  XML-declaration construct entirely; the html4 lane now does the same (the
+  WHATWG lane keeps its specified bogus-comment shape). Red-first gtest pins
+  the contract: `xml_declaration=0` emits no declaration, `1` emits exactly
+  the serializer's own — never the input's remnant, never `??`. Engine suite
+  2047/2047; canon's battery 9/9.
+
+
+## [1.9.364] - 2026-10-16
+
+### Added
+
+- **parse diagnostics carry severity classification (#1749, PR #1752).**
+  Two append-only `LeptrisDiagKind` refinements so embedders can implement
+  raise-on-fatal / recover-on-recoverable without string matching:
+  `LEPTRIS_DIAG_UNESCAPED_LT` — the #1748 unescaped-`<` recovery is a
+  strict-fatal class and now records its own kind instead of the generic
+  RECOVER bucket; and the ancestor-implicit-close recovery records
+  `LEPTRIS_DIAG_MISMATCHED_TAG` (libxml2 reports the same shape as a tag
+  mismatch), reserving `LEPTRIS_DIAG_UNCLOSED_ELEMENT` for the
+  still-open-at-EOF fatal class. Record messages unchanged; enum is
+  append-only.
+
+
 ## [1.9.363] - 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.363
+    VERSION 1.9.365
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

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

@@ -290,6 +290,10 @@ typedef enum {
      * implicitly), and an element still open at EOF. Append-only. */
     LEPTRIS_DIAG_MISMATCHED_TAG,
     LEPTRIS_DIAG_UNCLOSED_ELEMENT,
+    /* leptris#1748: an unescaped '<' in text folded into the run —
+     * RECOVERABLE-lane record of a STRICT-FATAL class (the strict
+     * path fails the parse; severity mapping: fatal). Append-only. */
+    LEPTRIS_DIAG_UNESCAPED_LT,
     LEPTRIS_DIAG_COUNT_
 } LeptrisDiagKind;
 

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

@@ -1755,7 +1755,7 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                 leptris_diag_emit(
                     &p.doc->parse_diags, &p.doc->parse_diag_count,
                     &p.doc->parse_diag_cap,
-                    LEPTRIS_DIAG_RECOVER, NULL,
+                    LEPTRIS_DIAG_UNESCAPED_LT, NULL,
                     "Unescaped < not allowed in a text node");
                 const char* nq = lt + 1;
                 const char* nlt =
@@ -2142,11 +2142,17 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                         while ((int)p.depth - 1 > anc) {
                             LeptrisElement ce =
                                 p.open_stack[p.depth - 1];
+                            /* #1749 severity: the implicit close
+                             * is the MISMATCH recovery (libxml2
+                             * reports a tag mismatch; recoverable
+                             * class) — UNCLOSED_ELEMENT stays
+                             * reserved for the still-open-at-EOF
+                             * fatal class. */
                             leptris_diag_emit(
                                 &p.doc->parse_diags,
                                 &p.doc->parse_diag_count,
                                 &p.doc->parse_diag_cap,
-                                LEPTRIS_DIAG_UNCLOSED_ELEMENT, NULL,
+                                LEPTRIS_DIAG_MISMATCHED_TAG, NULL,
                                 "Element %s closed implicitly by </%.*s>",
                                 elem_name(ce),
                                 (int)close_local_len, close_local);

data/vendor-src/libleptris/src/leptris/html/html_parse.c

@@ -6685,6 +6685,19 @@ static LeptrisDocument html_parse_shared(
             size_t dlen = (size_t)(de > ds ? de - ds : 0);
             char* tgt = (char*)leptris_pool_alloc(b.pool, tlen + 1);
             char* dat = (char*)leptris_pool_alloc(b.pool, dlen + 1);
+            /* libxml2 HTML parity (#1748): the XML-declaration
+             * construct ('<?xml ...?>') is an XML-ism — the HTML
+             * lane skips it entirely. Retaining it as a PI made the
+             * data carry the terminator '?' (serialized
+             * '<?xml ...??>'), and the declaration metadata + PI
+             * doubled when the serializer's xml_declaration rode
+             * along. */
+            if (tlen == 3 && (ts[0] | 0x20) == 'x' &&
+                (ts[1] | 0x20) == 'm' && (ts[2] | 0x20) == 'l') {
+                p = (de < end) ? de + 1 : end;
+                text = p;
+                continue;
+            }
             if (tgt && dat) {
                 memcpy(tgt, ts, tlen);
                 tgt[tlen] = 0;

data/vendor-src/libleptris/test/html/test_html_builder.cpp

@@ -188,3 +188,43 @@ TEST(HtmlBuilder, RawTextElementNotEscaped) {
     EXPECT_EQ(out.find("&lt;"), std::string::npos) << out;
     leptris_document_free(d);
 }
+
+/* leptris#1748: the XML-declaration construct ('<?xml ...?>') in
+ * HTML input is an XML-ism — libxml2's HTML parser skips it, and
+ * retaining it as a PI (data carrying the terminator '?') made
+ * serialization emit '<?xml ...??>' and double the declaration when
+ * the serializer's own xml_declaration rode along. */
+TEST(HtmlBuilder, Html4DropsXmlDeclarationProlog) {
+    const char* html =
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+        "<html xmlns=\"http://www.w3.org/1999/xhtml\">"
+        "<head><title>t</title></head><body><p>x</p></body></html>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument d =
+        leptris_parse_html4_string(html, strlen(html), &st);
+    ASSERT_EQ(st, LEPTRIS_OK);
+    ASSERT_NE(d, nullptr);
+    for (int decl = 0; decl < 2; decl++) {
+        LeptrisSerializeOptions opts;
+        memset(&opts, 0, sizeof(opts));
+        opts.xml_declaration = decl;
+        opts.encoding = "UTF-8";
+        char* s = leptris_document_serialize(d, &opts);
+        ASSERT_NE(s, nullptr);
+        std::string out(s);
+        leptris_free_string(s);
+        EXPECT_EQ(out.find("??"), std::string::npos)
+            << "decl=" << decl << " got: " << out.substr(0, 90);
+        /* decl=0: the prolog never leaks. decl=1: exactly the
+         * serializer's own declaration — never two, never the
+         * input's remnant. */
+        size_t decls = 0;
+        for (size_t at = out.find("<?xml"); at != std::string::npos;
+             at = out.find("<?xml", at + 1))
+            decls++;
+        EXPECT_EQ(decls, (size_t)decl)
+            << "decl=" << decl << " got: " << out.substr(0, 90);
+        EXPECT_NE(out.find("<html"), std::string::npos) << out;
+    }
+    leptris_document_free(d);
+}

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

@@ -799,8 +799,17 @@ TEST(ParseRecover, MismatchedCloseKeepsTreeAndDropsStray) {
     EXPECT_STREQ(leptris_element_text(a), "x");
     /* Two recoveries: the stray </b> drops, and <a> closes
      * implicitly when </root> names the ancestor (libxml2 reports
-     * both as well). */
+     * both as well). Both are MISMATCHED_TAG — the #1749 severity
+     * contract keeps UNCLOSED_ELEMENT for the EOF class only. */
     EXPECT_EQ(leptris_document_parse_diag_count(doc), 2u);
+    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_MISMATCHED_TAG);
+    ASSERT_EQ(leptris_document_parse_diag(doc, 1, &kind, msg,
+                                          sizeof(msg)), 1);
+    EXPECT_EQ(kind, LEPTRIS_DIAG_MISMATCHED_TAG);
     leptris_document_free(doc);
 }
 
@@ -867,7 +876,10 @@ TEST(ParseRecover, BareLtInTextKeepsTreeAndRecords) {
     char msg[128] = {0};
     ASSERT_EQ(leptris_document_parse_diag(doc, 0, &kind, msg,
                                           sizeof(msg)), 1);
-    EXPECT_EQ(kind, LEPTRIS_DIAG_RECOVER);
+    /* #1749: the kind carries the severity — unescaped '<' is a
+     * STRICT-FATAL class recovered on the lenient lane, its own
+     * kind, not the generic RECOVER bucket. */
+    EXPECT_EQ(kind, LEPTRIS_DIAG_UNESCAPED_LT);
     leptris_document_free(doc);
 }
 

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.363",
+  "version": "1.9.365",
   "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.364.1
+  version: 1.9.365.1
 platform: aarch64-linux
 authors:
 - Ribose Inc.