leptris 1.9.376.0 → 1.9.377.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0399e31ae9c0ba48036d105e43bcbd52bfed938ae0c7f588d072e36ce7cd511
-  data.tar.gz: f9b7cfe41cec036205e5feeda04553a060168d780c699341d8b698b856da59c5
+  metadata.gz: eaa5ce5dfd171e7a4931f40dcd4ec8e901bd4895f20776df74daee75595e2294
+  data.tar.gz: d843a2dac00c737e4e203ea1375f0575fd1df0ec2b854ad0134e87bfcad3493f
 SHA512:
-  metadata.gz: d8640e69644843b589c390ccc368c85b24dc29e42c01dbd379e309409e0e187630230f7606852fb15f70a9ec58342a5f4154fd86c5625dfab47637d9b14f6c47
-  data.tar.gz: 71a4de8644e8e1ed5d0191fea52ce57384e823ef83b8136d13756d79fec5dc56cf9ac969552d895458aa1410c91724018cc91142f38e0aa62c57ae4034e09ab3
+  metadata.gz: 3d81ecd1df498f7fd65db0531affc0a61ab9df1f79123a19b05759c77d0a64c91299e771a2b314347a3565a3f721b63685b01723f7afa21e40063eb94a2c0774
+  data.tar.gz: 1aa12f5eaad5f1566a9cc2b070f09db64433714ced23cdac8c16a1d34056b2f43748b45fecdbc8c590a1084e694cd8ec38549af406e8e68aee9e69d9203edec1

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.376"
+LIBLEPTRIS_VERSION = "1.9.377"
 # 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.376.0"
+  VERSION = "1.9.377.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.376
+- libleptris v1.9.377
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## [Unreleased]
 
+## [1.9.377] - 2026-10-20
+
+### Added
+
+- **html: verdict parity 1508 to 1532 of 1555 (PR #1797).** Five
+  emission slices, each grounded in html5lib's parser/tokenizer
+  source and gated by the #1771 corpus harness with zero want=clean
+  regressions: misplaced in-body caption/col/…/tr and `<frame>`
+  (unexpected-start-tag-ignored) plus the stray `</p>` phase codes;
+  after-html/after-body/after-frameset character codes
+  (expected-eof-but-got-char, unexpected-char-after-body,
+  unexpected-char-after-frameset); unterminated-comment tokenizer
+  codes (eof-in-comment, eof-in-comment-double-dash);
+  plaintext-at-EOF and the `</` tokenizer EOF codes; and a
+  phase-aware depth-0 stray-end-tag branch covering raw-text names,
+  void elements and menuitem (end-tag-after-implied-root before
+  html, after-body/-frameset/after-html variants, otherwise
+  unexpected-end-tag). Tree parity stays 1555/1555; the verdict
+  floor rose from 1508 to 1532.
+
+
 ## [1.9.376] - 2026-10-20
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -4035,6 +4035,13 @@ static void h_append(HBuilder* b, LeptrisNodeRef n) {
                 if (*q != ' ' && *q != '\t' && *q != '\n' &&
                     *q != '\r') { ws = 0; break; }
         if (!ws) {
+            /* AfterFrameset processCharacters reports
+             * unexpected-char-after-frameset; the after-</html>
+             * flavor is reported by the expected-eof block below. */
+            if (!b->after_html)
+                h_diag(b, "unexpected-char-after-frameset",
+                       b->err_line_memo_off,
+                       "characters after </frameset>");
             /* Every whitespace character inserts, every
              * non-whitespace one drops (tests2:7: " te st" ->
              * "  "). Filter in place, like after-frameset. */
@@ -4057,7 +4064,20 @@ static void h_append(HBuilder* b, LeptrisNodeRef n) {
             for (const char* q = tt; *q; q++)
                 if (*q != ' ' && *q != '\t' && *q != '\n' &&
                     *q != '\r') { nonws = 1; break; }
-        if (nonws) b->after_body_done = 1;
+        if (nonws) {
+            b->after_body_done = 1;
+            /* AfterAfterBody/AfterAfterFrameset processCharacters
+             * report expected-eof-but-got-char; AfterBody reports
+             * unexpected-char-after-body (tests2:55, tests19:41). */
+            if (b->after_html)
+                h_diag(b, "expected-eof-but-got-char",
+                       b->err_line_memo_off,
+                       "characters after </html>");
+            else
+                h_diag(b, "unexpected-char-after-body",
+                       b->err_line_memo_off,
+                       "characters after </body>");
+        }
     }
     /* Doc-start mixed run: the ws prefix is "before html"
      * whitespace and drops (doctype01:31, tests19:79). Tightest
@@ -5797,12 +5817,25 @@ static LeptrisDocument html_parse_shared(
                 size_t clen = cclose
                                   ? (size_t)(ce - cs)
                                   : (size_t)(end - cs);
-                if (!cclose)
+                if (!cclose) {
+                    /* Tokenizer EOF states: a trailing "--" is
+                     * comment-end-double-dash (tests2:59), anything
+                     * else is a plain eof-in-comment (tests2:35/43). */
+                    if (b.whatwg) {
+                        int dd = clen >= 2 && cs[clen - 1] == '-' &&
+                                 cs[clen - 2] == '-';
+                        h_diag(&b,
+                               dd ? "eof-in-comment-double-dash"
+                                  : "eof-in-comment",
+                               (size_t)(end - b.input_base),
+                               "comment reaches end of input");
+                    }
                     /* Unterminated at EOF: html5lib drops the
                      * trailing dash run (tests2:59: <!--x-- keeps
                      * data "x"). */
                     while (clen > 0 && cs[clen - 1] == '-')
                         clen--;
+                }
                 p = cclose ? ce + cclose : end;
                 LeptrisCommentNode* c = leptris_comment_create(
                     cs, clen, b.pool);
@@ -6111,6 +6144,18 @@ static LeptrisDocument html_parse_shared(
             {
                 const char* ns2 = p + 2;
                 if (b.whatwg && ns2 >= end) {
+                    /* Tokenizer: EOF in the tag-open state emits
+                     * expected-closing-tag-but-got-eof and the two
+                     * characters as text (tests1:38); in the
+                     * initial mode that text also reports the
+                     * missing doctype. */
+                    h_diag(&b, "expected-closing-tag-but-got-eof",
+                           (size_t)(p - b.input_base),
+                           "end tag at end of input");
+                    if (!b.left_initial && !doc->doctype)
+                        h_diag(&b, "expected-doctype-but-got-chars",
+                               (size_t)(p - b.input_base),
+                               "characters in the initial mode");
                     if (text < p) {
                         LeptrisTextNode* t =
                             h_text_node(&b, text, p);
@@ -6259,21 +6304,35 @@ static LeptrisDocument html_parse_shared(
                 text = p;
                 continue;
             }
-            /* Stray raw-text end tag with no open stack: the raw-text
-             * element completed during its start-tag handling, so this
-             * token cannot close anything. html5lib's InHead/InBody
-             * endTagOther reports unexpected-end-tag once the tree has
-             * content (the synthesized body is the special node);
-             * with nothing seen yet the phase errors differently and
-             * the initial-mode checks above already cover it. */
-            if (b.whatwg && nlen && b.depth == 0 && b.top_tail) {
+            /* Stray end tags with no open stack. The raw-text family
+             * completes during start-tag handling; void elements and
+             * menuitem have no in-body end handler. html5lib's
+             * endTagOther reports by phase: before-html is
+             * end-tag-after-implied-root; AfterBody/AfterFrameset
+             * and AfterAfter* have their own codes; InHead/InBody/
+             * AfterHead report unexpected-end-tag. */
+            if (b.whatwg && nlen && b.depth == 0) {
                 char rn[16];
                 size_t rl = nlen < sizeof(rn) - 1 ? nlen : sizeof(rn) - 1;
                 for (size_t i = 0; i < rl; i++) rn[i] = h_lower(ns[i]);
                 rn[rl] = 0;
-                if (h_is_rawtext_name(rn)) {
-                    h_diag(&b, "unexpected-end-tag",
-                           (size_t)(p - b.input_base),
+                int stray = h_is_rawtext_name(rn) ||
+                            (h_is_void(rn) && strcmp(rn, "br") != 0) ||
+                            strcmp(rn, "menuitem") == 0;
+                if (stray) {
+                    const char* code = "unexpected-end-tag";
+                    if (b.after_html)
+                        code = "expected-eof-but-got-end-tag";
+                    else if (b.after_body)
+                        code = "unexpected-end-tag-after-body";
+                    else if (b.frameset && b.after_frameset)
+                        code = "unexpected-end-tag-after-frameset";
+                    else if (b.frameset)
+                        code = "unexpected-end-tag-in-frameset";
+                    else if (!b.top_tail && !b.head_tag_seen &&
+                             !b.body_seen && !b.body_tag_seen)
+                        code = "end-tag-after-implied-root";
+                    h_diag(&b, code, (size_t)(p - b.input_base),
                            "</%s> has no matching open element", rn);
                     p = q;
                     text = p;
@@ -6295,6 +6354,19 @@ static LeptrisDocument html_parse_shared(
                 for (size_t i = 0; i < cl; i++)
                     lname[i] = h_lower(ns[i]);
                 lname[cl] = 0;
+                /* InBody endTagOther: a VOID element has no end
+                 * handler, so a stray end tag reports
+                 * unexpected-end-tag (tests25:15-20: </keygen>).
+                 * </br> is endTagBr and acts as <br> above. */
+                if (b.whatwg && h_is_void(lname) &&
+                    strcmp(lname, "br") != 0) {
+                    h_diag(&b, "unexpected-end-tag",
+                           (size_t)(p - b.input_base),
+                           "</%s> is a void element", lname);
+                    p = q;
+                    text = p;
+                    continue;
+                }
                 if (!h_is_void(lname)) {
                     if (b.whatwg &&
                         strcmp(lname, "menuitem") == 0) {
@@ -6433,6 +6505,16 @@ static LeptrisDocument html_parse_shared(
                                (size_t)(p - b.input_base),
                                "</%s> with no open heading", lname);
                     }
+                    /* InHead/AfterHead endTagOther: a </p> before
+                     * body content is dropped with unexpected-end-tag
+                     * and inserts nothing (tests19:3). */
+                    if (b.whatwg && strcmp(lname, "p") == 0 &&
+                        !b.body_seen && (b.head_tag_seen ||
+                                         b.head_end_seen) &&
+                        !b.frameset && !b.after_body && !b.after_html)
+                        h_diag(&b, "unexpected-end-tag",
+                               (size_t)(p - b.input_base),
+                               "</p> outside the body phase");
                     /* #659 13.2.6.4.17: </p> with no p in button
                      * scope inserts an EMPTY <p> and closes it
                      * (tests1:29) — the stray tag still leaves a
@@ -6460,6 +6542,13 @@ static LeptrisDocument html_parse_shared(
                                 break;
                         }
                         if (!p_open) {
+                            /* InBody endTagP: no p in button scope
+                             * is a parse error even though the
+                             * empty p is still inserted
+                             * (tests2:60). */
+                            h_diag(&b, "unexpected-end-tag",
+                                   (size_t)(p - b.input_base),
+                                   "</p> with no p in scope");
                             LeptrisElement pe =
                                 h_open_element(&b, "p");
                             (void)pe;
@@ -7694,6 +7783,13 @@ static LeptrisDocument html_parse_shared(
                 }
             }
             if (!tbl_ctx) {
+                /* InBody startTagMisplaced: caption/col/colgroup/
+                 * head/tbody/td/tfoot/th/thead/tr in body is a
+                 * parse error and the token is ignored
+                 * (tests25:7 <body><col>A). */
+                h_diag(&b, "unexpected-start-tag-ignored",
+                       (size_t)(p - b.input_base),
+                       "<%s> ignored in the body phase", name);
                 /* The TOKEN is ignored - surrounding character
                  * tokens keep flowing into body (the html-merge
                  * flush pattern). */
@@ -7712,6 +7808,20 @@ static LeptrisDocument html_parse_shared(
          * an ignored <frameset> vanishes). */
         if (b.whatwg && strcmp(name, "frame") == 0 &&
             (!b.frameset || b.after_frameset)) {
+            /* InBody reports the frame as a misplaced start tag
+             * (tests25:10); the after-</frameset> phase names its
+             * own code (the after-</html> phase is reported at the
+             * start-tag dispatch). */
+            if (!b.after_html) {
+                if (!b.frameset)
+                    h_diag(&b, "unexpected-start-tag-ignored",
+                           (size_t)(p - b.input_base),
+                           "<frame> ignored in the body phase");
+                else
+                    h_diag(&b, "unexpected-start-tag-after-frameset",
+                           (size_t)(p - b.input_base),
+                           "<frame> after </frameset>");
+            }
             while (q < end && *q != '>') q++;
             p = (q < end) ? q + 1 : end;
             text = p;
@@ -8531,6 +8641,13 @@ static LeptrisDocument html_parse_shared(
                        "input",
                        name);
             }
+            /* PLAINTEXT has no close form: it is still open at
+             * EOF, so InBody processEOF reports the unclosed
+             * element (tests18:2-7, tests19:6). */
+            if (b.whatwg && cq >= end && strcmp(name, "plaintext") == 0)
+                h_diag(&b, "expected-closing-tag-but-got-eof",
+                       (size_t)(end - b.input_base),
+                       "plaintext reaches end of input");
             b.depth--;   /* the raw element is complete */
             text = p;
             continue;

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

@@ -990,6 +990,14 @@ TEST(Html5LibCorpus, ErrorVerdictParity) {
      * out-of-my-head tags; the select/table/foreign slice adds
      * unexpected-input-in-select, hidden-input-in-table, and
      * unexpected-html-element-in-foreign-content; the tokenizer
-     * slice adds need-space-after-doctype. Only raises. */
-    EXPECT_GE(parity, (size_t)1508);
+     * slice adds need-space-after-doctype; the misplaced-tag slice
+     * adds in-body caption/col/…/tr and frame (ignored), plus the
+     * stray </p> phase codes; the character-phase slice adds
+     * expected-eof-but-got-char and unexpected-char-after-body/
+     * -frameset; the tokenizer EOF slice adds eof-in-comment and
+     * eof-in-comment-double-dash; the plaintext/EOF slice adds the
+     * plaintext open-at-EOF and the "</" tokenizer EOF codes; the
+     * stray-end-tag slice makes the depth-0 branch phase-aware for
+     * raw-text, void and menuitem names. Only raises. */
+    EXPECT_GE(parity, (size_t)1532);
 }

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.376",
+  "version": "1.9.377",
   "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.376.0
+  version: 1.9.377.0
 platform: ruby
 authors:
 - Ribose Inc.