leptris 1.9.368.1-aarch64-linux → 1.9.370.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a55d9429274a6351b83c25eb8a3e366a5cd1ea7effc953661ee0ba125607d58
-  data.tar.gz: 824310d407eefe2202433914bf71a25eae55ac5bd6ddbae8e8577837c0a24955
+  metadata.gz: a3d358fab2e812dfe82e177d601ca62c5e43e3392582a47569de67dd19f9dd78
+  data.tar.gz: 7d4ec42ca0d1024740566a2c76b5078db549ff372fc4d31c86a6e21abd096581
 SHA512:
-  metadata.gz: 191bd7787891ea2ef62337b6f858cb43db048f58ad1cb83cba4dd5635298430884d221fdabbe8d663797a5e405ecaa804bc53fef2ef6b3abb9484f3a99f6a7cf
-  data.tar.gz: 0defbddcc67344faef208aaecc7d06b833b87d967c8731a7f08d95eacf142600052af1f304aff6e92323ac624bc3999eb91e7836390f559e787390ae873e990c
+  metadata.gz: 2aa939744bd1bfdcb74978308bf337ef3fc93fdb9a1427683c9d6d9cb6d37de346b447f4c3e184cc9853eb7797dc106529a404b518aacdceafecd1dd0da7c0d4
+  data.tar.gz: 47d69f33b7b5b4ced5b5bcb17888e594d4e107fd32bc8ee8619ed3ef2df8b769396778a73ada8ae4b0720e15d945f87bb7a473783b8f3fb11cc8e80b9a9d5a3c

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.368"
+LIBLEPTRIS_VERSION = "1.9.370"
 # 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.368.1"
+  VERSION = "1.9.370.0"
 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.368
+- libleptris v1.9.370
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,34 @@
 ## [Unreleased]
 
+## [1.9.370] - 2026-10-18
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.369] - 2026-10-18
+
+### Added
+
+- **test: falsifiable kind-safety pin for the #487 class (PR #1765).**
+  The #487 fix's original contract test passes on both sides of the fix
+  (a pool-created detached text survives the element-form misread), so
+  it could not catch a regression. `OversizedTextKindSafe` uses the
+  shape that actually crashed in the wild — HEAP-BACKED text (oversized
+  content leaves the inline-window allocation) — and asserts the
+  kind-safe contract end to end: get_document answers the text's own
+  owner document (the observable red on pre-fix source was NULL — the
+  same element-form misread that wild-pointer-walked under the
+  reporter's GC timing), and the oversized text attaches through the
+  addr face and round-trips byte-exactly. Falsifiability verified both
+  ways: RED on pre-fix source (deterministic NULL), GREEN on the
+  fixed source. Test-only.
+
+
 ## [1.9.368] - 2026-10-18
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -4890,6 +4890,14 @@ static void h_split_head_body(HBuilder* b, LeptrisElement html,
             int hty = leptris_node_get_type(head_end);
             if (hty == LEPTRIS_NODE_TYPE_COMMENT ||
                 hty == LEPTRIS_NODE_TYPE_PI) {
+                /* leptris#389: once a structural <body> token has
+                 * opened the in-body window, a comment is BODY
+                 * content (13.2.6.4.4 inserts at the current node)
+                 * — end the head run here so the comment leads the
+                 * rest into the body, instead of joining the head
+                 * run or the after-head deferral. */
+                if (b->body_tag_seen)
+                    break;
                 if (b->whatwg_head_set) {
                     if (past_head_end) {
                         /* After </head>: the comment is an html
@@ -5221,6 +5229,16 @@ head_end = leptris_node_get_next_sibling(head_end);
     if (b->whatwg_head_set && !b->frameset &&
         (rest || b->head_end_seen)) {
         if (b->head_end_seen) {
+            /* leptris#389: a structural <body> start tag opens the
+             * in-body window — comments after it insert at the
+             * current node (13.2.6.4.4 in-body comment insertion)
+             * and belong INSIDE the body. The after-head front
+             * peel (13.2.6.4.6) only governs the pre-body window;
+             * once body_tag_seen armed the body, leading comments
+             * of the rest stay body content. The head-commit and
+             * after-body peel below stay unconditional. */
+            int in_body_window = b->body_tag_seen;
+            if (!in_body_window) {
             /* Front peel: leading comments/PIs of the rest. Uses
              * its OWN last-marker so the ws-registered suffix
              * segment is MERGED (ws first, then comments), never
@@ -5254,6 +5272,7 @@ head_end = leptris_node_get_next_sibling(head_end);
                     suffix_first = peel_first;
                 suffix_last = peel_last;
             }
+            }
             /* A comment tokenized BEFORE </html> but after
              * </body> rides in the rest - peel the trailing run
              * to the html level, exactly like the </body>-only

data/vendor-src/libleptris/test/dom/test_dom.cpp

@@ -3078,6 +3078,36 @@ TEST(DomAttachInstalled, ForeignMixedChainTextBeforeElement) {
  * usually survives the misread; a recycled or heap-backed text
  * hands the walk a wild pointer and the process dies. The face (and
  * get_document itself) must be kind-safe. */
+/* leptris-ruby#487, the falsifiable pin: the crashing texts in the
+ * wild were HEAP-BACKED (oversized content leaves the inline window —
+ * the pool-created text of TextChildAttachIsKindSafe survives the
+ * element-form misread, so that test alone cannot go red). An
+ * oversized text must resolve its document through its OWN owner
+ * field, attach, and round-trip — never through element-form reads. */
+TEST(DomAttachInstalled, OversizedTextKindSafe) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument d = leptris_parse_string("<r/>", 4, &st);
+    ASSERT_NE(d, nullptr);
+    LeptrisElement root = leptris_document_root(d);
+
+    std::string big(8192, 'x');
+    LeptrisNodeRef text = leptris_text_node_create(d, big.c_str());
+    ASSERT_NE(text, nullptr);
+    EXPECT_EQ(leptris_node_get_type(text), LEPTRIS_NODE_TYPE_TEXT);
+
+    /* kind-safe document resolution: the text's OWN owner doc */
+    EXPECT_EQ(leptris_element_get_document((LeptrisElement)text), d);
+
+    EXPECT_EQ(leptris_element_add_child_addr_installed(
+                  (uintptr_t)root, (uintptr_t)text, NULL),
+              LEPTRIS_OK);
+    char* out = leptris_element_serialize(root, nullptr);
+    ASSERT_NE(out, nullptr);
+    EXPECT_EQ(std::string(out), "<r>" + big + "</r>");
+    leptris_free_string(out);
+    leptris_document_free(d);
+}
+
 TEST(DomAttachInstalled, TextChildAttachIsKindSafe) {
     LeptrisStatus st = LEPTRIS_OK;
     LeptrisDocument d = leptris_parse_string("<r/>", 4, &st);

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

@@ -10,6 +10,10 @@ extern "C" {
 #include <cstring>
 #include <string>
 
+static bool h389_ieq(const char* a, const char* b) {
+    return a && b && strcmp(a, b) == 0;
+}
+
 namespace {
 
 /* Tree-shape dumps force the XML method (ext.html_method = -1,
@@ -2270,3 +2274,63 @@ TEST(HtmlParse, SetTextSurvivesSerialization) {
         leptris_document_free(doc);
     }
 }
+
+/* leptris#389: a comment token following ignored <html>/<body>
+ * start tags must insert at the current node (WHATWG 13.2.6.4.4
+ * in-body comment insertion) — the ignored start tags do not
+ * change where subsequent comments land, and the after-head
+ * front-peel (13.2.6.4.6) does not govern the in-body window.
+ * The structural <body> handler only stashes attributes; the
+ * body materializes at the split, and the comment must ride the
+ * rest INTO it — not peel to the html level (which orphaned it
+ * when the split short-circuited on the explicit-body walk). */
+TEST(HtmlParse, InBodyCommentAfterIgnoredStructuralStartTags) {
+    LeptrisStatus st;
+    const char* doc1 =
+        "<body><html><body><!-- c --><p>Test</p></body></html></body>";
+    LeptrisDocument d = leptris_parse_html_string(doc1, strlen(doc1), &st);
+    ASSERT_NE(d, nullptr);
+    LeptrisElement body = nullptr;
+    for (LeptrisNodeRef c = leptris_node_first_child(
+             (LeptrisNodeRef)leptris_document_root(d));
+         c; c = leptris_node_next_sibling((LeptrisNodeRef)c))
+        if (leptris_node_get_type(c) == LEPTRIS_NODE_TYPE_ELEMENT &&
+            h389_ieq(leptris_element_name((LeptrisElement)c), "body"))
+            body = (LeptrisElement)c;
+    ASSERT_NE(body, nullptr);
+    int comments = 0, elems = 0;
+    for (LeptrisNodeRef c = leptris_node_first_child(
+             (LeptrisNodeRef)body);
+         c; c = leptris_node_next_sibling((LeptrisNodeRef)c)) {
+        if (leptris_node_get_type(c) == LEPTRIS_NODE_TYPE_COMMENT)
+            comments++;
+        if (leptris_node_get_type(c) == LEPTRIS_NODE_TYPE_ELEMENT)
+            elems++;
+    }
+    EXPECT_EQ(comments, 1);
+    EXPECT_EQ(elems, 1);
+    leptris_document_free(d);
+}
+
+TEST(HtmlParse, InBodyCommentBodyFirstShape) {
+    LeptrisStatus st;
+    const char* doc1 = "<body><!-- c --><p>Test</p>";
+    LeptrisDocument d = leptris_parse_html_string(doc1, strlen(doc1), &st);
+    ASSERT_NE(d, nullptr);
+    LeptrisElement body = nullptr;
+    for (LeptrisNodeRef c = leptris_node_first_child(
+             (LeptrisNodeRef)leptris_document_root(d));
+         c; c = leptris_node_next_sibling((LeptrisNodeRef)c))
+        if (leptris_node_get_type(c) == LEPTRIS_NODE_TYPE_ELEMENT &&
+            h389_ieq(leptris_element_name((LeptrisElement)c), "body"))
+            body = (LeptrisElement)c;
+    ASSERT_NE(body, nullptr);
+    int comments = 0;
+    for (LeptrisNodeRef c = leptris_node_first_child(
+             (LeptrisNodeRef)body);
+         c; c = leptris_node_next_sibling((LeptrisNodeRef)c))
+        if (leptris_node_get_type(c) == LEPTRIS_NODE_TYPE_COMMENT)
+            comments++;
+    EXPECT_EQ(comments, 1);
+    leptris_document_free(d);
+}

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.368",
+  "version": "1.9.370",
   "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.368.1
+  version: 1.9.370.0
 platform: aarch64-linux
 authors:
 - Ribose Inc.