leptris 1.9.364.2-aarch64-linux → 1.9.366.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3d3bd0e468a92817427100b26e5ca0bcb2fc9f4a588881df21ca73baf345203
-  data.tar.gz: da6fe398fa6311cbe26803546a60598ab84c90c41ed3ca4e3ac2c36c2a4fbf8e
+  metadata.gz: d847172247048f7d9acb3898a3a63e61bd4744632e7b5213ca7c13694fee85e9
+  data.tar.gz: 48c6b128d630e278ca1a747509b9403bb8c335fbf91a01764869c0298fb1c719
 SHA512:
-  metadata.gz: 9fbb91daefb87daab4c8c6c4c4234d53ff5e175cc09efbb90441cfb3d5bc4fd03802040da5ade5809214501c5dc6cb6b8565a2d5928a74d687d51125bc8d40d2
-  data.tar.gz: 1807c7274c5cce84427991747c41c061da829082816f69d26276805f16e429386a8c0fb456fbb8673be28a6fd6b60ccf4387a6b79dfd21392663af41d7de0f3f
+  metadata.gz: 3f0ace5e75d874349929f02f71f3dc685d34e4a42966c024112e7480a031a5cb77b93ab6dca92616ae78bc4dbf9c02a8dab9ce1def4321230867be0ecd631f1c
+  data.tar.gz: f372629ba2782ee782c405bddb40766bef226eab32cb2f763ffd681b0f31766d21a32e61e5dc1db28759096a3942baae380d7ab923013e954a2e3e8c2ead336b

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.364"
+LIBLEPTRIS_VERSION = "1.9.366"
 # 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.2"
+  VERSION = "1.9.366.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.364
+- libleptris v1.9.366
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,45 @@
 ## [Unreleased]
 
+## [1.9.366] - 2026-10-17
+
+### Fixed
+
+- **dom: the foreign leaf adopt copies exactly the argument node (#1755, PR #1757).**
+  `adopt_for_splice`'s non-element branch ran a wholesale sibling-chain copy
+  (`copy_leaf_chain`) whose switch had no ELEMENT case: any mixed-content
+  chain — a text node whose next sibling is the element that follows it, the
+  standard fragment shape lutaml/moxml produce — hit `default:` and the whole
+  append failed with `LEPTRIS_ERROR_MEMORY` ("Memory allocation failed": a
+  lie; nothing was out of memory). The run-copy was also wrong for every
+  caller that reaches this path — the binding's fragment loop and moxml's
+  NodeSet iteration append fragment children individually, so a chain copy
+  duplicated every later sibling even where it succeeded. The foreign leaf
+  adopt now copies exactly the argument (doc-level leaves were already
+  single-node for the same reason, #1539); the single-caller chain copier is
+  deleted. This is the deterministic face of the Ruby 4.0 render crash
+  (leptris-ruby#489): the GC-stressed metanorma collection render goes
+  2 failures -> 0. Engine suite 2048/2048; binding suite 1094/1094.
+
+
+
+## [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

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/leptris/dom/element_modify.c

@@ -359,74 +359,6 @@ static LeptrisNode* copy_leaf_one(LeptrisNode* c,
     }
 }
 
-/* #1534: copy a non-element node (plus its linked tail — the #540
- * chain shape) into the target document's pool. Same per-kind
- * creation helpers the subtree copier uses. */
-static LeptrisNode* copy_leaf_chain(LeptrisNode* head,
-                                    struct leptris_document* target) {
-    LeptrisNode* copy_head = NULL;
-    LeptrisNode* copy_tail = NULL;
-    for (LeptrisNode* c = head; c;
-         c = leptris_node_get_next_sibling(c)) {
-        LeptrisNode* cc = NULL;
-        switch (c->type) {
-            case LEPTRIS_NODE_TYPE_TEXT: {
-                LeptrisTextNode* t = (LeptrisTextNode*)c;
-                const char* content = leptris_textnode_content(t);
-                cc = (LeptrisNode*)leptris_text_create(
-                    content, t->content_len, target->pool, target);
-                break;
-            }
-            case LEPTRIS_NODE_TYPE_CDATA: {
-                LeptrisCDATANode* cd = (LeptrisCDATANode*)c;
-                cc = (LeptrisNode*)leptris_cdata_create(
-                    cd->content, cd->content ? strlen(cd->content) : 0,
-                    target->pool);
-                break;
-            }
-            case LEPTRIS_NODE_TYPE_COMMENT: {
-                LeptrisCommentNode* cm = (LeptrisCommentNode*)c;
-                cc = (LeptrisNode*)leptris_comment_create(
-                    cm->content,
-                    cm->content ? strlen(cm->content) : 0,
-                    target->pool);
-                break;
-            }
-            case LEPTRIS_NODE_TYPE_PI: {
-                LeptrisPINode* pi = (LeptrisPINode*)c;
-                cc = (LeptrisNode*)leptris_pi_create(
-                    pi->target, pi->target ? strlen(pi->target) : 0,
-                    pi->data ? pi->data : "",
-                    pi->data ? strlen(pi->data) : 0, target->pool);
-                break;
-            }
-            case LEPTRIS_NODE_TYPE_ENTITY_REF: {
-                LeptrisEntityRefNode* er = (LeptrisEntityRefNode*)c;
-                cc = (LeptrisNode*)leptris_entity_ref_create(
-                    er->name, er->name ? strlen(er->name) : 0,
-                    target->pool);
-                break;
-            }
-            default:
-                cc = NULL;
-        }
-        if (!cc) {
-            /* OOM mid-chain: copies already made live only in the
-             * target pool — no caller-visible handle exists, and
-             * document free reclaims them (the same conservatism
-             * copy_subtree_detached uses on !cc). */
-            return NULL;
-        }
-        if (!copy_head) {
-            copy_head = cc;
-        } else {
-            leptris_node_set_next_sibling(copy_tail, cc);
-        }
-        copy_tail = cc;
-    }
-    return copy_head;
-}
-
 static LeptrisNode* adopt_for_splice(LeptrisNode* node,
                                      struct leptris_document* target) {
     if (!node || !target) return node;
@@ -465,13 +397,15 @@ static LeptrisNode* adopt_for_splice(LeptrisNode* node,
          * the target — its pool dies with the target, so the node
          * moves by reference. */
         if (src->absorbed_by == target) return node;
-        /* top == node: a DOC-LEVEL leaf (prolog/epilog, #580) —
-         * its sibling chain spans unrelated nodes (including the
-         * root element), so copy exactly the argument (#1539).
-         * An in-element leaf keeps the #540 chain shape. */
-        if (top == node) return copy_leaf_one(node, target);
-        LeptrisNode* copy = copy_leaf_chain(node, target);
-        return copy;
+        /* Copy exactly the argument (#1755): the callers of this
+         * face append fragment children INDIVIDUALLY (the binding's
+         * fragment loop, moxml's NodeSet iteration), so a wholesale
+         * run copy duplicated every later sibling — and its missing
+         * ELEMENT case failed the whole append with
+         * LEPTRIS_ERROR_MEMORY on the first mixed-content chain.
+         * Doc-level leaves (prolog/epilog, #580) were already
+         * single-node for the same reason (#1539). */
+        return copy_leaf_one(node, target);
     }
     /* Type-safe walk to the chain top: get_document reads
      * element-form fields and misreads non-element structs. */

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/dom/test_dom.cpp

@@ -3019,6 +3019,58 @@ TEST(DomAttachInstalled, ForeignAttachReportsCopyAddress) {
     leptris_document_free(target);
 }
 
+/* leptris#1755: a foreign MIXED-CONTENT fragment hands the
+ * engine a text node whose sibling chain carries the following
+ * element. The leaf adopt ran a WHOLESALE chain copy that had no
+ * ELEMENT case — the element hit default: and the whole append
+ * failed with LEPTRIS_ERROR_MEMORY ("Memory allocation failed" —
+ * a lie; nothing was out of memory). Every caller of this face
+ * appends fragment children INDIVIDUALLY (the binding's fragment
+ * loop, moxml's NodeSet iteration), so the foreign leaf adopt
+ * copies exactly the argument node — the sibling run stays in the
+ * source for its own appends. */
+TEST(DomAttachInstalled, ForeignMixedChainTextBeforeElement) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* src = "<f>lead<item>t</item>tail</f>";
+    LeptrisDocument frag = leptris_parse_string(src, strlen(src), &st);
+    ASSERT_NE(frag, nullptr);
+    LeptrisDocument target = leptris_parse_string("<doc/>", 6, &st);
+    ASSERT_NE(target, nullptr);
+    LeptrisElement troot = leptris_document_root(target);
+    LeptrisElement froot = leptris_document_root(frag);
+    /* node-level first child: the TEXT "lead" (the element-level
+     * face would skip it and return <item>). */
+    LeptrisNodeRef text = leptris_node_first_child((LeptrisNodeRef)froot);
+    ASSERT_NE(text, nullptr);
+    ASSERT_EQ(leptris_node_get_type(text), LEPTRIS_NODE_TYPE_TEXT);
+
+    EXPECT_EQ(leptris_element_add_child_addr(
+                  (uintptr_t)troot, (uintptr_t)text),
+              LEPTRIS_OK);
+    /* exactly the argument: no sibling run rides along (serialize
+     * pins the child set; child_count is element-oriented) */
+    char* out = leptris_element_serialize(troot, nullptr);
+    ASSERT_NE(out, nullptr);
+    EXPECT_STREQ(out, "<doc>lead</doc>");
+    leptris_free_string(out);
+
+    /* the binding's loop continues: the element sibling appends on
+     * its own, and the trailing text with it — no duplication of
+     * the element the first adopt must NOT have carried */
+    LeptrisElement item = leptris_element_first_child_any(froot);
+    ASSERT_NE(item, nullptr);
+    EXPECT_EQ(leptris_element_add_child_addr(
+                  (uintptr_t)troot, (uintptr_t)item),
+              LEPTRIS_OK);
+    /* the source dies; the installed copies must survive */
+    leptris_document_free(frag);
+    out = leptris_element_serialize(troot, nullptr);
+    ASSERT_NE(out, nullptr);
+    EXPECT_STREQ(out, "<doc>lead<item>t</item></doc>");
+    leptris_free_string(out);
+    leptris_document_free(target);
+}
+
 TEST(DomAttachInstalled, SameDocumentReturnsArgument) {
     LeptrisStatus st = LEPTRIS_OK;
     LeptrisDocument d = leptris_parse_string("<r/>", 4, &st);

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/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.364",
+  "version": "1.9.366",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.364.2
+  version: 1.9.366.1
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-16 00:00:00.000000000 Z
+date: 2026-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi