leptris 1.9.370.1 → 1.9.371.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0da354b1a07e2345161752a5b7ca7902696e6072ea64918b0daa658188e3baa2
-  data.tar.gz: 5752801d285e7eb4da1fb597f866ccf317fea25032ee79e8f75e336398a8be2d
+  metadata.gz: 7d4aadf1e16972c36b3c8668694e03a5cbb5e1af83f5ffd5886386b672271be9
+  data.tar.gz: 3f6d316bf97d593866b9a93a6fe39389bece411605c20f0b812fd1e823f898ea
 SHA512:
-  metadata.gz: 794d1477836616595314bfcd20529e55a17739357575d5d51f45aeee589f9e57e855053590eebf6e717cb592936d7c5998042e7706cee0325616d835cc925edc
-  data.tar.gz: 793321d127eaece55428d75deb14bfe9496f207480bac4f0ed10aa54f868722d5a69478e5949b72deb224788f0b51af20b86d73c37899ca99c212f33ef52ed9f
+  metadata.gz: 5f22ba905b799eabfe7988d5eb584ee6b1751672e79db8fac3d96146a0be437dde212f00046d44e108d70b698b89cfff6f701abf18ed29ff72090bb521fe414e
+  data.tar.gz: f5bcb476c7e447ccd09b730bf8be20dcaa7cbc00f4cc704f9d0a7c329410da460ae1fb4b924cf2c0099783de22cc3a78f14e8fca6e19dcb58fe6bf150c99a2bd

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.370"
+LIBLEPTRIS_VERSION = "1.9.371"
 # 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/ext/leptris/native/native.c

@@ -1445,6 +1445,25 @@ static VALUE nn_create_child(VALUE self, VALUE name)
     return out;
 }
 
+/* The #204 write row: gates + version bump + engine set in ONE C
+ * frame on the TypedData self — the caller skips the binding
+ * wrapper's Ruby arg plumbing (nf_set_binding_attribute's
+ * discipline, parameterized by subclass). */
+static VALUE nn_set_attribute(VALUE self, VALUE name, VALUE value)
+{
+    struct native_node *n;
+    int st;
+
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    document_advance_version(n->document);
+    st = f_set_attr(n->ptr, RSTRING_PTR(StringValue(name)),
+                    StringValueCStr(value));
+    if (st != 0)
+        rb_raise(c_runtime_error,
+                 "leptris_element_set_attribute failed (%d)", st);
+    return value;
+}
+
 static VALUE nn_append_child(VALUE self, VALUE child)
 {
     struct native_node *n, *c;
@@ -3537,6 +3556,7 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     rb_define_method(c_native_node, "name", nn_name, 0);
     rb_define_method(c_native_node, "content", nn_content, 0);
     rb_define_method(c_native_node, "content=", nn_content_set, 1);
+    rb_define_method(c_native_node, "set_attribute", nn_set_attribute, 2);
     rb_define_method(c_native_node, "attribute", nn_attribute, 1);
     rb_define_alias(c_native_node, "[]", "attribute");
     /* Unshadowed aliases for consumers whose contract modules shadow

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.370.1"
+  VERSION = "1.9.371.0"
 end

data/lib/leptris/xml/document.rb

@@ -888,9 +888,21 @@ 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-ruby#1771: the machine-readable code + position
+      # (the §13.2.5 token name for HTML parse lints).
+      code_buf = ::FFI::MemoryPointer.new(:char, 128)
+      line_buf = ::FFI::MemoryPointer.new(:int)
+      col_buf = ::FFI::MemoryPointer.new(:int)
+      Leptris::XML::FFI.leptris_document_parse_diag_code(
+        c_ptr, i, code_buf, 128, line_buf, col_buf)
+      code = code_buf.read_string
+      code = nil if code.empty?
       Leptris::XML::SyntaxError.new(
         msg_buf.read_string.force_encoding(Encoding::UTF_8),
-        severity: DIAG_SEVERITY.fetch(kind_buf.read_int, :recoverable))
+        severity: DIAG_SEVERITY.fetch(kind_buf.read_int, :recoverable),
+        line: line_buf.read_int.zero? ? nil : line_buf.read_int,
+        column: col_buf.read_int.zero? ? nil : col_buf.read_int,
+        code: code)
     end.compact
   end
 

data/lib/leptris/xml/ffi.rb

@@ -555,6 +555,11 @@ module Leptris
       # the parse; only an entirely empty result is an error.
       attach_function :leptris_parse_html_string,
         [:string, :size_t, :pointer], :leptris_document
+      # leptris-ruby#1771: the WHATWG engine with per-call options
+      # (LEPTRIS_PARSE_COLLECT_HTML_ERRORS records the parse-error
+      # token stream on the document).
+      attach_function :leptris_parse_html_string_flags,
+        [:string, :size_t, :size_t, :pointer], :leptris_document
       # HTML4/libxml2-compatibility mode (1.9.104, #659): the same
       # tolerant tokenizer and Nokogiri document shape, except
       # leading script/style stay in <body> (libxml2's shape —
@@ -1531,6 +1536,11 @@ attach_function :leptris_parse_string,
         [:leptris_document], :size_t
       attach_function :leptris_document_parse_diag,
         [:leptris_document, :size_t, :pointer, :pointer, :size_t], :int
+      # leptris-ruby#1771: the diag's machine-readable code + line +
+      # column (the §13.2.5 parse-error token name for HTML lints).
+      attach_function :leptris_document_parse_diag_code,
+        [:leptris_document, :size_t, :pointer, :size_t, :pointer,
+         :pointer], :int
       attach_function :leptris_dtd_parse,
         [:string, :size_t], :leptris_dtd
       attach_function :leptris_dtd_free, [:leptris_dtd], :void

data/lib/leptris/xml.rb

@@ -83,17 +83,27 @@ module Leptris
     # (script/style/noscript/template/... lift) and foster
     # parenting (1.9.105) — html5lib corpus 294/1555 vs Nokogiri's
     # 372; the shapes genuinely differ by spec.
-    def self.parse_html(html, mode: :html4)
+    def self.parse_html(html, mode: :html4, collect_errors: false)
       html = html.to_s
-      entry =
-        case mode
-        when :html4 then Leptris::XML::FFI.method(:leptris_parse_html4_string)
-        when :whatwg then Leptris::XML::FFI.method(:leptris_parse_html_string)
-        else
-          raise ArgumentError,
-            "mode must be :html4 or :whatwg, got #{mode.inspect}"
-        end
-      raw = entry.call(html, html.bytesize, nil)
+      # leptris-ruby#1771: collect_errors records the §13.2.5
+      # parse-error token stream as document errors (code + line +
+      # column); the WHATWG engine only (the html4 compat lane
+      # keeps the libxml2 posture).
+      if collect_errors && mode == :whatwg
+        flags = 64 # LEPTRIS_PARSE_COLLECT_HTML_ERRORS
+        raw = Leptris::XML::FFI.leptris_parse_html_string_flags(
+          html, html.bytesize, flags, nil)
+      else
+        entry =
+          case mode
+          when :html4 then Leptris::XML::FFI.method(:leptris_parse_html4_string)
+          when :whatwg then Leptris::XML::FFI.method(:leptris_parse_html_string)
+          else
+            raise ArgumentError,
+              "mode must be :html4 or :whatwg, got #{mode.inspect}"
+          end
+        raw = entry.call(html, html.bytesize, nil)
+      end
       if raw.null?
         raise Leptris::XML::ParseError,
           "HTML parse failed: #{Leptris::XML::FFI.leptris_last_error}"
@@ -111,16 +121,21 @@ module Leptris
     # SyntaxError shape — a message plus optional position — served
     # by Document#errors.
     class SyntaxError < Error
-      attr_reader :message, :line, :column, :severity
+      attr_reader :message, :line, :column, :severity, :code
 
       # 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)
+      # code: the machine-readable token (leptris-ruby#1771 — the
+      # §13.2.5 parse-error name for HTML lints, e.g.
+      # "unexpected-tag-in-body"); nil when the diag has no code.
+      def initialize(message, line: nil, column: nil, severity: :recoverable,
+                     code: nil)
         @message = message
         @line = line
         @column = column
         @severity = severity
+        @code = code
         super(message)
       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.370
+- libleptris v1.9.371
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,34 @@
 ## [Unreleased]
 
+## [1.9.371] - 2026-10-19
+
+### Added
+
+- **html: the §13.2.5 parse-error lint surface (#1771, PR #1772).**
+  `LEPTRIS_PARSE_COLLECT_HTML_ERRORS` on the new
+  `leptris_parse_html_string_flags` entry records the WHATWG
+  parse-error token stream as diagnostics — machine-readable **code**
+  (the spec token name: "duplicate-attribute", "eof-in-tag",
+  "unexpected-doctype", ...), **line**, **column** — one class
+  (RECOVER), per the issue's "a single class + code is enough for
+  canon to map" contract. The diag record gains a machine-readable
+  code field; the read side gains
+  `leptris_document_parse_diag_code` (the existing kind+message face
+  is untouched — no ABI break). Slice 1 instruments the sites the
+  parser already self-documents: duplicate-attribute (structural
+  stash + generic start-tag paths), eof-in-tag (all three drop
+  shapes), unexpected-doctype outside the initial mode, and the
+  malformed-construct bogus-comment fallback; follow-up slices
+  extend the coverage per the §13.2.5 list. Off by default — the
+  tree construction is exactly as fast without the bit. Engine suite
+  2044/2044 including the html5lib corpus gate and the export-surface
+  gate; MSVC format-attribute guard included.
+### Fixed
+
+- guard the h_diag format attribute for MSVC (html)
+
+
+
 ## [1.9.370] - 2026-10-18
 
 <!-- Edit this section with the actual release notes. -->

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -152,6 +152,28 @@ LEPTRIS_API int leptris_document_parse_diag(LeptrisDocument doc,
                                             char* message,
                                             size_t message_cap);
 
+/**
+ * Read one parse diagnostic's machine-readable code and position
+ * (leptris-ruby#1771: the §13.2.5 parse-error token name for HTML
+ * lints; NULL code for diags without one).
+ *
+ * @param doc Document handle
+ * @param index Diagnostic index (< leptris_document_parse_diag_count)
+ * @param code Out: NUL-terminated code buffer (may be NULL)
+ * @param code_cap Capacity of code (ignored when code NULL)
+ * @param line Out: 1-based line (may be NULL; 0 when unknown)
+ * @param col Out: 1-based column (may be NULL; 0 when unknown)
+ * @return 1 on success; 0 for NULL doc or out-of-range index
+ *
+ * Memory: Code is copied into the caller's buffer; diagnostics
+ *         are owned by the document until leptris_document_free.
+ */
+LEPTRIS_API int leptris_document_parse_diag_code(LeptrisDocument doc,
+                                                 size_t index,
+                                                 char* code,
+                                                 size_t code_cap,
+                                                 int* line, int* col);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -72,6 +72,21 @@ LEPTRIS_API LeptrisDocument leptris_parse_html4_string(const char* html,
                                                        size_t length,
                                                        LeptrisStatus* status);
 
+/**
+ * Parse HTML with per-call options (leptris-ruby#1771).
+ *
+ * Identical to leptris_parse_html_string; `flags` may carry
+ * LEPTRIS_PARSE_COLLECT_HTML_ERRORS to record the WHATWG §13.2.5
+ * parse-error token stream as diagnostics (read via
+ * leptris_document_parse_diag_count + leptris_document_parse_diag +
+ * leptris_document_parse_diag_code).
+ *
+ * @return Document, or NULL on failure
+ */
+LEPTRIS_API LeptrisDocument leptris_parse_html_string_flags(
+    const char* buf, size_t len, LeptrisParseFlags flags,
+    LeptrisStatus* status);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -245,7 +245,12 @@ typedef enum {
      * is dropped, unclosed elements close at EOF. Each recovery
      * records a parse diagnostic (mismatched-tag / unclosed-element
      * kind). Without the bit the parse fails as before. */
-    LEPTRIS_PARSE_RECOVER = 32u
+    LEPTRIS_PARSE_RECOVER = 32u,
+    /* leptris-ruby#1771: record the WHATWG §13.2.5 parse-error
+     * token stream as diagnostics (code + line + column) on the
+     * HTML parse — the lint layer validators need. Opt-in: the
+     * tree construction stays exactly as fast without it. */
+    LEPTRIS_PARSE_COLLECT_HTML_ERRORS = 64u
 } LeptrisParseFlags;
 
 /* ============================================================================

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

@@ -22,6 +22,7 @@ LeptrisDiag* leptris_diag_emit(LeptrisDiag** list, int* count, int* cap,
     LeptrisDiag* d = &(*list)[*count];
     d->kind = kind;
     d->offender_name = NULL;
+    d->code = NULL;
     d->line = 0;
     d->col_start = 0;
     d->col_end = 0;
@@ -46,10 +47,40 @@ LeptrisDiag* leptris_diag_emit(LeptrisDiag** list, int* count, int* cap,
     return d;
 }
 
+LeptrisDiag* leptris_diag_emit_code(LeptrisDiag** list, int* count, int* cap,
+                                    LeptrisDiagKind kind, const char* code,
+                                    int line, int col, const char* fmt, ...) {
+    if (!list || !count || !cap) return NULL;
+    if (*count == *cap) {
+        int nc = *cap ? *cap * 2 : 8;
+        LeptrisDiag* nl = (LeptrisDiag*)realloc(
+            *list, sizeof(LeptrisDiag) * (size_t)nc);
+        if (!nl) return NULL;
+        *list = nl;
+        *cap = nc;
+    }
+    LeptrisDiag* d = &(*list)[*count];
+    d->kind = kind;
+    d->offender_name = NULL;
+    d->code = code ? leptris_strdup(code) : NULL;
+    d->line = line;
+    d->col_start = col;
+    d->col_end = 0;
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(d->message, sizeof(d->message), fmt, ap);
+    va_end(ap);
+    (*count)++;
+    return d;
+}
+
 void leptris_diag_free(LeptrisDiag** list, int* count, int* cap) {
     if (!list) return;
     if (*list && count) {
-        for (int i = 0; i < *count; i++) free((*list)[i].offender_name);
+        for (int i = 0; i < *count; i++) {
+            free((*list)[i].offender_name);
+            free((*list)[i].code);
+        }
     }
     free(*list);
     *list = NULL;

data/vendor-src/libleptris/src/leptris/dom/diag.h

@@ -27,6 +27,10 @@ typedef struct LeptrisDiag {
                                    * validated document is freed — musl
                                    * unmaps the region and the report
                                    * pass segfaulted reading it. */
+    /* #1771: the machine-readable CODE — the §13.2.5 parse-error
+     * token name for HTML lints ("unexpected-tag-in-body"), NULL
+     * when the diag has no code. Captured at emit (strdup'd). */
+    char* code;
 
     int line;
     int col_start;                /* Jing: element/attr errors */
@@ -53,6 +57,18 @@ LeptrisDiag* leptris_diag_emit(LeptrisDiag** list, int* count, int* cap,
 #endif
     ;
 
+/* #1771: the code-carrying variant — same record, plus the
+ * machine-readable code string (strdup'd into the record). Line/col
+ * come from the caller (the tokenizer's own position); the record's
+ * node-derived position path does not apply. */
+LeptrisDiag* leptris_diag_emit_code(LeptrisDiag** list, int* count, int* cap,
+                                    LeptrisDiagKind kind, const char* code,
+                                    int line, int col, const char* fmt, ...)
+#if defined(__GNUC__)
+    __attribute__((format(printf, 8, 9)))
+#endif
+    ;
+
 /* Release a record list (the messages are inline, so this is one
  * free + reset). */
 void leptris_diag_free(LeptrisDiag** list, int* count, int* cap);

data/vendor-src/libleptris/src/leptris/error.c

@@ -153,4 +153,19 @@ LEPTRIS_API int leptris_document_parse_diag(LeptrisDocument doc,
         message[message_cap - 1] = '\0';
     }
     return 1;
-}
+}
+
+LEPTRIS_API int leptris_document_parse_diag_code(LeptrisDocument doc,
+                                                 size_t index,
+                                                 char* code,
+                                                 size_t code_cap,
+                                                 int* line, int* col) {
+    if (!doc || index >= (size_t)doc->parse_diag_count) return 0;
+    struct LeptrisDiag* d = (struct LeptrisDiag*)doc->parse_diags + index;
+    if (code && code_cap) {
+        snprintf(code, code_cap, "%s", d->code ? d->code : "");
+    }
+    if (line) *line = d->line;
+    if (col) *col = d->col_start;
+    return 1;
+}

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

@@ -17,8 +17,10 @@
 #include "../dom/comment.h"
 #include "../dom/doctype.h"
 #include "../dom/root_doc_map.h"
+#include "../dom/diag.h"
 #include "../dom/cdata.h"
 #include "../dom/pi.h"
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
@@ -2687,6 +2689,15 @@ typedef struct {
     /* #659 master mode flag (the per-slice flags below derive from
      * the same html_parse_shared arg). */
     int whatwg;
+    /* #1771: the parse-lint channel — record the §13.2.5
+     * parse-error token stream when the option bit is set. The
+     * input base + length turn token offsets into 1-based
+     * line/column at emit (amortized: last-line memo). */
+    int collect_errors;
+    const char* input_base;
+    size_t input_len;
+    size_t err_line_memo_off;
+    int err_line_memo;
     /* #659 frameset mode (WHATWG): a <frameset> before any body
      * content REPLACES the body — the commit synthesis emits
      * html > [head, frameset]. */
@@ -2877,6 +2888,8 @@ static int h_in_head_noscript(HBuilder* b) {
 /* #659: stash the attributes of a dropped structural tag —
  * pool-owned flat name/value pairs, applied to the synthesized
  * element at commit. */
+static void h_diag(HBuilder* b, const char* code, size_t off,
+                   const char* fmt, ...);
 static void h_stash_attrs(HBuilder* b, const char* q, const char* end,
                           char** attrs, int* n) {
     while (q < end && *q != '>' && *n + 1 < 32) {
@@ -2927,7 +2940,12 @@ static void h_stash_attrs(HBuilder* b, const char* q, const char* end,
             int dup = 0;
             for (int j = 0; j + 1 < *n; j += 2)
                 if (strcmp(attrs[j], aname) == 0) { dup = 1; break; }
-            if (!dup) {
+            if (dup) {
+                h_diag(b, "duplicate-attribute",
+                       (size_t)(as - b->input_base),
+                       "duplicate attribute '%s' ignored; first value "
+                       "wins", aname);
+            } else {
                 attrs[(*n)++] = aname;
                 attrs[(*n)++] = aval;
             }
@@ -5532,8 +5550,43 @@ static LeptrisTextNode* h_text_node(HBuilder* b, const char* s,
     return leptris_text_create(dec, dlen, b->pool, b->doc);
 }
 
+/* #1771: record one §13.2.5 parse-error token. Code is the spec
+ * token name; `off` is the byte offset into the owned input.
+ * Line/column are computed with a forward-only line memo (lint
+ * volumes are ordered, so the walk amortizes). No-op unless the
+ * option bit is set — the tree construction stays exactly as
+ * fast without it. */
+#if defined(__GNUC__)
+static void h_diag(HBuilder* b, const char* code, size_t off,
+                   const char* fmt, ...)
+    __attribute__((format(printf, 4, 5)));
+#endif
+static void h_diag(HBuilder* b, const char* code, size_t off,
+                   const char* fmt, ...) {
+    if (!b->collect_errors || !b->doc) return;
+    if (off > b->input_len) off = b->input_len;
+    int line = b->err_line_memo, col = 1;
+    size_t from = b->err_line_memo_off;
+    if (off < from) { from = 0; line = 1; }
+    for (size_t i = from; i < off; i++) {
+        if (b->input_base[i] == '\n') { line++; col = 1; }
+        else col++;
+    }
+    b->err_line_memo = line;
+    b->err_line_memo_off = off;
+    char detail[192];
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(detail, sizeof(detail), fmt, ap);
+    va_end(ap);
+    leptris_diag_emit_code(&b->doc->parse_diags, &b->doc->parse_diag_count,
+                           &b->doc->parse_diag_cap, LEPTRIS_DIAG_RECOVER,
+                           code, line, col, "%s", detail);
+}
+
 static LeptrisDocument html_parse_shared(
-    const char* buf, size_t len, LeptrisStatus* status, int whatwg) {
+    const char* buf, size_t len, LeptrisStatus* status, int whatwg,
+    LeptrisParseFlags flags) {
     if (status) *status = LEPTRIS_OK;
     if (!buf) {
         if (status) *status = LEPTRIS_ERROR_NULL_ARG;
@@ -5561,6 +5614,8 @@ static LeptrisDocument html_parse_shared(
     b.doc = doc;
     b.pool = doc->pool;
     b.whatwg = whatwg;
+    b.collect_errors =
+        (flags & LEPTRIS_PARSE_COLLECT_HTML_ERRORS) ? 1 : 0;
     b.whatwg_head_set = whatwg;
     b.whatwg_foster = whatwg;
     b.whatwg_adopt = whatwg;
@@ -5576,6 +5631,10 @@ static LeptrisDocument html_parse_shared(
     }
     memcpy(owned, buf, len);
     owned[len] = '\0';
+    /* #1771: the lint channel's offset base — after `owned` exists. */
+    b.input_base = owned;
+    b.input_len = len;
+    b.err_line_memo = 1;
     b.owned = owned;
     h_id_luts_init();
 
@@ -5724,6 +5783,10 @@ static LeptrisDocument html_parse_shared(
                 }
                 if (dt_kw && (doc->doctype || b.left_initial ||
                               h_in_head_noscript(&b))) {
+                    h_diag(&b, "unexpected-doctype",
+                           (size_t)(p - b.input_base),
+                           "DOCTYPE token outside the initial mode "
+                           "is ignored");
                     while (q < end && *q != '>') q++;
                     p = (q < end) ? q + 1 : end;
                     text = p;
@@ -5946,6 +6009,10 @@ static LeptrisDocument html_parse_shared(
                     }
                     const char* q2 = ns2;
                     while (q2 < end && *q2 != '>') q2++;
+                    h_diag(&b, "unexpected-character-in-tag",
+                           (size_t)(ns2 - b.input_base),
+                           "malformed tag construct became a bogus "
+                           "comment");
                     h_bogus_comment(&b, ns2, (size_t)(q2 - ns2));
                     p = (q2 < end) ? q2 + 1 : end;
                     text = p;
@@ -5955,6 +6022,8 @@ static LeptrisDocument html_parse_shared(
             /* #659 eof-in-tag: an unterminated END tag at EOF is
              * dropped too (same 13.2.5.44 rule). */
             if (b.whatwg && !memchr(p, '>', (size_t)(end - p))) {
+                h_diag(&b, "eof-in-tag", (size_t)(p - b.input_base),
+                       "end tag at EOF is dropped");
                 if (text < p) {
                     LeptrisTextNode* t = h_text_node(&b, text, p);
                     if (t) h_append(&b, (LeptrisNodeRef)t);
@@ -6760,6 +6829,9 @@ static LeptrisDocument html_parse_shared(
          * a parse error — the tag is dropped, pending text lands,
          * parsing ends (webkit01:4: '<di' -> empty body). */
         if (b.whatwg && !memchr(p, '>', (size_t)(end - p))) {
+            /* #1771: eof-in-tag (13.2.5.44). */
+            h_diag(&b, "eof-in-tag", (size_t)(p - b.input_base),
+                   "start tag at EOF is dropped");
             if (text < p) {
                 LeptrisTextNode* t = h_text_node(&b, text, p);
                 if (t) h_append(&b, (LeptrisNodeRef)t);
@@ -6800,6 +6872,10 @@ static LeptrisDocument html_parse_shared(
                 scan++;
             }
             if (!closed) {
+                /* #1771: eof-in-tag — the unterminated START tag
+                 * is dropped (13.2.5.44, webkit02:5). */
+                h_diag(&b, "eof-in-tag", (size_t)(p - b.input_base),
+                       "start tag at EOF is dropped");
                 if (text < p) {
                     LeptrisTextNode* t =
                         h_text_node(&b, text, p);
@@ -7861,6 +7937,14 @@ static LeptrisDocument html_parse_shared(
                     vs = scan;
                     while (scan < end && *scan != quote) scan++;
                     vlen = (size_t)(scan - vs);
+                    if (scan >= end) {
+                        /* #1771: the quote never closed — 13.2.5
+                         * eof-in-tag. */
+                        h_diag(&b, "eof-in-tag",
+                               (size_t)(as - b.input_base),
+                               "attribute value at EOF is "
+                               "unterminated");
+                    }
                     if (scan < end) scan++;
                 } else {
                     vs = scan;
@@ -7883,6 +7967,13 @@ static LeptrisDocument html_parse_shared(
                 aval = (char*)"";
             }
             if (aval) {
+                /* #1771: a same-named attribute is ignored (first
+                 * value wins, 13.2.5.3 duplicate-attribute). */
+                if (leptris_element_attribute(e, aname))
+                    h_diag(&b, "duplicate-attribute",
+                           (size_t)(as - b.input_base),
+                           "duplicate attribute '%s' ignored; first "
+                           "value wins", aname);
                 /* #659: foreign attribute-name adjustment
                  * (viewBox, definitionURL, ...). */
                 const char* aadj =
@@ -8300,7 +8391,7 @@ LEPTRIS_API LeptrisDocument leptris_parse_html_string(
     /* #659: THE WHATWG ENGINE — the full "in head" set lifts into
      * the implied head (script/style/noscript/template/...). The
      * html5lib corpus is this entry's conformance meter. */
-    return html_parse_shared(buf, len, status, 1);
+    return html_parse_shared(buf, len, status, 1, LEPTRIS_PARSE_DEFAULT);
 }
 
 LEPTRIS_API LeptrisDocument leptris_parse_html4_string(
@@ -8308,5 +8399,13 @@ LEPTRIS_API LeptrisDocument leptris_parse_html4_string(
     /* #659: libxml2/Nokogiri compatibility — leading script/style
      * stay in body (title/meta/link/base still lift). The
      * committed Nokogiri reference trees measure this entry. */
-    return html_parse_shared(buf, len, status, 0);
+    return html_parse_shared(buf, len, status, 0, LEPTRIS_PARSE_DEFAULT);
+}
+
+LEPTRIS_API LeptrisDocument leptris_parse_html_string_flags(
+    const char* buf, size_t len, LeptrisParseFlags flags,
+    LeptrisStatus* status) {
+    /* #1771: the WHATWG engine with per-call options — the parse-
+     * lint bit rides here. */
+    return html_parse_shared(buf, len, status, 1, flags);
 }

data/vendor-src/libleptris/test/CMakeLists.txt

@@ -154,6 +154,7 @@ if(LEPTRIS_ENABLE_DUCET)
 endif()
 leptris_add_test(test_xquery      xquery/test_xquery.cpp)
 leptris_add_test(test_html        html/test_html.cpp)
+leptris_add_test(test_html_parse_errors html/test_html_parse_errors.cpp)
 leptris_add_test(test_html_builder html/test_html_builder.cpp)
 leptris_add_test(test_html_borrowed_names html/test_html_borrowed_names.cpp)
 leptris_add_test(test_html5lib     html/test_html5lib.cpp)

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

@@ -0,0 +1,102 @@
+// test/html/test_html_parse_errors.cpp — the #1771 parse-lint
+// surface: LEPTRIS_PARSE_COLLECT_HTML_ERRORS records the §13.2.5
+// parse-error token stream (code + line + column) on the document's
+// diagnostic list. Opt-in: without the bit the list stays empty and
+// the tree construction is unchanged.
+#include <gtest/gtest.h>
+#include <leptris.h>
+#include <leptris/html.h>
+#include <leptris/error.h>
+#include <cstring>
+
+namespace {
+
+struct Diag {
+    LeptrisDiagKind kind;
+    std::string code;
+    std::string message;
+    int line, col;
+};
+
+std::vector<Diag> drain(LeptrisDocument doc) {
+    std::vector<Diag> out;
+    size_t n = leptris_document_parse_diag_count(doc);
+    for (size_t i = 0; i < n; i++) {
+        LeptrisDiagKind kind = LEPTRIS_DIAG_INVALID;
+        char msg[256] = {0};
+        char code[64] = {0};
+        int line = 0, col = 0;
+        EXPECT_TRUE(leptris_document_parse_diag(doc, i, &kind, msg,
+                                                sizeof(msg)));
+        EXPECT_TRUE(leptris_document_parse_diag_code(doc, i, code,
+                                                     sizeof(code),
+                                                     &line, &col));
+        out.push_back({kind, code, msg, line, col});
+    }
+    return out;
+}
+
+}  // namespace
+
+TEST(HtmlParseErrors, OffByDefaultListStaysEmpty) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xml = "<a id=\"1\" id=\"2\">x</a>";
+    LeptrisDocument d = leptris_parse_html_string(xml, strlen(xml), &st);
+    ASSERT_NE(d, nullptr);
+    EXPECT_EQ(leptris_document_parse_diag_count(d), 0u);
+    leptris_document_free(d);
+}
+
+TEST(HtmlParseErrors, DuplicateAttributeCarriesSpecCode) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xml = "<a id=\"1\" id=\"2\">x</a>";
+    LeptrisDocument d = leptris_parse_html_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_COLLECT_HTML_ERRORS, &st);
+    ASSERT_NE(d, nullptr);
+    auto diags = drain(d);
+    ASSERT_GE(diags.size(), 1u);
+    bool found = false;
+    for (auto& dd : diags)
+        if (dd.code == "duplicate-attribute") found = true;
+    EXPECT_TRUE(found);
+    EXPECT_EQ(diags[0].kind, LEPTRIS_DIAG_RECOVER);
+    leptris_document_free(d);
+}
+
+TEST(HtmlParseErrors, EofInTagCarriesSpecCode) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xml = "<p>text<a href=\"";
+    LeptrisDocument d = leptris_parse_html_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_COLLECT_HTML_ERRORS, &st);
+    ASSERT_NE(d, nullptr);
+    auto diags = drain(d);
+    ASSERT_GE(diags.size(), 1u);
+    EXPECT_EQ(diags[0].code, "eof-in-tag");
+    EXPECT_EQ(diags[0].line, 1);
+    EXPECT_EQ(diags[0].col, 8);
+    leptris_document_free(d);
+}
+
+TEST(HtmlParseErrors, DoctypeOutsideInitialIgnored) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xml = "<div><!DOCTYPE html></div>";
+    LeptrisDocument d = leptris_parse_html_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_COLLECT_HTML_ERRORS, &st);
+    ASSERT_NE(d, nullptr);
+    auto diags = drain(d);
+    ASSERT_GE(diags.size(), 1u);
+    EXPECT_EQ(diags[0].code, "unexpected-doctype");
+    leptris_document_free(d);
+}
+
+TEST(HtmlParseErrors, LineColumnTrackRealLines) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xml = "<p>one</p>\n<p>two</p>\n<a id=\"1\" id=\"2\">x</a>";
+    LeptrisDocument d = leptris_parse_html_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_COLLECT_HTML_ERRORS, &st);
+    ASSERT_NE(d, nullptr);
+    auto diags = drain(d);
+    ASSERT_GE(diags.size(), 1u);
+    EXPECT_EQ(diags[0].line, 3);
+    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.370",
+  "version": "1.9.371",
   "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.370.1
+  version: 1.9.371.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-18 00:00:00.000000000 Z
+date: 2026-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -841,6 +841,7 @@ files:
 - vendor-src/libleptris/test/html/test_html5lib.cpp
 - vendor-src/libleptris/test/html/test_html_borrowed_names.cpp
 - vendor-src/libleptris/test/html/test_html_builder.cpp
+- vendor-src/libleptris/test/html/test_html_parse_errors.cpp
 - vendor-src/libleptris/test/memory/test_arena.cpp
 - vendor-src/libleptris/test/memory/test_doc_block.cpp
 - vendor-src/libleptris/test/memory/test_mut_recycle.cpp