yeptris 0.6.31.2-aarch64-linux → 0.6.32.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 183da7797c7f5b350cd690df5ce9d68192e876b67d9d894d86e699fd525f893a
-  data.tar.gz: b650b33d6927a1ebb0659925eac2fadf73bd7a55bf87a7c3b5acf140a1463209
+  metadata.gz: 27054940f25d07b0af5eebd56ff85e79de42305a7ab59e34f714b48ab523458c
+  data.tar.gz: aef30cec9183a9caf10864e3d112d109bf3c81f93000c11c87d5e4547b22ba50
 SHA512:
-  metadata.gz: c215e725c05e52335ac398ce44bf5a28f33456e7941da00bc4349f6a0715629fe14f87cfe7e558e00ca6c0406253677d9a1fff5bc03dab95ae2591dc88b3d72d
-  data.tar.gz: 30307baad810806be2ba5007d544d1f1de11151d38f21a93dd040289bb6dbb392b242fd6897c30c9b8cd37b67fa43343c698513c4fc22e4d3790151d85dc311c
+  metadata.gz: 5567d722a33e0f30f60ce64345be3c2ee57657bdd884b82f159f6ec9d5ec415ce6c83cd70ae317d3449e13824fd5a018b1e3be7c62440e02832c6c2b9bf479cf
+  data.tar.gz: 1e178a8fe0eda68348d962919ed6523c0347cc851de265804307a1d09aa2c5c80cc2859452d19b4c0fe1c14463184974d017d0000220db234d135905b5ada08c

data/lib/yeptris.rb

@@ -3,7 +3,7 @@
 module Yeptris
   # The gem's version lives in the parent namespace's file — the last
   # internal require (yeptris/version) retired with it.
-  VERSION = "0.6.31.2".freeze
+  VERSION = "0.6.32.1".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a

data/vendor/libyeptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(yeptris
-    VERSION 0.6.31
+    VERSION 0.6.32
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

data/vendor/libyeptris/src/yeptris/dom/ytape.c

@@ -1118,6 +1118,14 @@ static size_t yt_flat_run(yep_ytape* t, const char* p, size_t pos, size_t len, u
         if (col + 1 != run_cc) {
             return pos; /* off-column: the pop/nest logic owns it */
         }
+        /* document markers are the engine's alone — the "..."+content
+         * error law lives there (the nightly's marshal crasher) */
+        if (le - li >= 3 && (memcmp(p + li, "...", 3) == 0 || memcmp(p + li, "---", 3) == 0)) {
+            size_t mk2 = li + 3;
+            if (mk2 >= le || p[mk2] == ' ' || p[mk2] == '\t') {
+                return pos;
+            }
+        }
         unsigned char c = (unsigned char)p[li];
         if (c == '\t' || c == '-' || c == '&' || c == '!' || c == '*' || c == '\'' || c == '"' ||
             c == '[' || c == '{' || c == '|' || c == '>' || c == '%' || c == '?') {
@@ -1293,6 +1301,8 @@ static int yt_f_run(yt_fused* F) {
             if (n1 == ' ' || n1 == '\t') {
                 dash = 1;
             }
+        } else if (c == '-' && line_indent + 1 >= line_end) {
+            dash = 1; /* a line-end dash is an indicator, not the scalar "-" */
         }
         size_t next = line_end < len ? (size_t)line_end + 1 : len;
         if (!blank && !comment) {
@@ -1301,6 +1311,18 @@ static int yt_f_run(yt_fused* F) {
             if (c == '\t') {
                 return 1; /* tab-led content: the engine's error */
             }
+            /* document markers are the engine's alone: only it carries
+             * the "..."+content error law (the nightly's marshal
+             * crasher, "a: b\n... vi an :  }" — the runner swallowed
+             * the post-'...' content as a pair) */
+            if (col == 0 && line_end - line_indent >= 3 &&
+                (memcmp(p + line_indent, "...", 3) == 0 ||
+                 memcmp(p + line_indent, "---", 3) == 0)) {
+                size_t mk = line_indent + 3;
+                if (mk >= line_end || p[mk] == ' ' || p[mk] == '\t') {
+                    return 1;
+                }
+            }
             if (dash && depth > 0 && st[depth].pending && col >= st[depth].indent) {
                 /* the pending key resolves into a sequence: its own
                  * frame (the key's map survives below it) */
@@ -1391,8 +1413,19 @@ static int yt_f_run(yt_fused* F) {
                         vc == '?') {
                         return 1;
                     }
-                    if (vc == '-' && vt + 1 < line_end && (p[vt + 1] == ' ' || p[vt + 1] == '\t')) {
-                        return 1; /* nested dash: the engine's nested seq */
+                    if (!yep_plain_first_ok(vc)) {
+                        return 1; /* ']'/','/'}'/'@'/'`' first: no plain
+                                     item can start there (the nightly's
+                                     marshal crasher, "x:\n- ]\"#") — the
+                                     engine errors cleanly */
+                    }
+                    if (vc == '-' && (vt + 1 >= line_end || p[vt + 1] == ' ' || p[vt + 1] == '\t' ||
+                                      p[vt + 1] == '#')) {
+                        return 1; /* nested dash (incl. line-end — the
+                                     nightly's "n:\n- -\t" crasher: a
+                                     trailing bare '-' is an indicator,
+                                     never the plain scalar "-"): the
+                                     engine's nested seq */
                     }
                     /* compact map item "- k: v"? */
                     for (size_t ic = vt; ic < vend; ic++) {

data/vendor/libyeptris/src/yeptris/emit/writer.c

@@ -168,6 +168,20 @@ static void emit_dq(yep_writer* w, const char* p, uint32_t n) {
             i += 2;
             continue;
         }
+        /* U+FFFE/U+FFFF are noncharacters: the printable validator
+         * rejects them raw, so emitting them raw makes the document
+         * un-re-parseable (the nightly's "["\\uFFFE"]" catch). Their
+         * escapes re-enter the doc the same way they left. */
+        if (c == 0xef && i + 2 < n && (unsigned char)p[i + 1] == 0xbf &&
+            ((unsigned char)p[i + 2] == 0xbe || (unsigned char)p[i + 2] == 0xbf)) {
+            if (run) {
+                wr_put(w, p + i - run, run);
+                run = 0;
+            }
+            wr_put(w, (unsigned char)p[i + 2] == 0xbe ? "\\uFFFE" : "\\uFFFF", 6);
+            i += 2;
+            continue;
+        }
         /* U+FEFF must never ride raw: at the buffer head it IS the
          * BOM and re-parse would strip it (the nightly's UTF-32LE
          * catch); Psych escapes it everywhere ("") */
@@ -393,6 +407,11 @@ static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key,
             has_bom = 1;
             break;
         }
+        if ((unsigned char)p[k] == 0xef && k + 2 < len && (unsigned char)p[k + 1] == 0xbf &&
+            ((unsigned char)p[k + 2] == 0xbe || (unsigned char)p[k + 2] == 0xbf)) {
+            has_nel = 1; /* noncharacter: only its escape re-parses */
+            break;
+        }
     }
     if (has_nel || has_bom) {
         return YEP_SC_DQ;
@@ -556,6 +575,27 @@ static void emit_alias_ex(yep_emitter* em, const yep_dnode* n) {
     }
 }
 
+/* Tag bytes outside ns-tag-char ride %XX (the parse side decodes them
+ * per the URI rule — a decoded newline emitted raw was the nightly's
+ * byte-instability crasher "!%0a"). Uppercase hex, libyaml's form. */
+static void wr_tag_uri(yep_writer* w, const yep_view* v) {
+    static const char hd[] = "0123456789ABCDEF";
+    const unsigned char* p = (const unsigned char*)v->p;
+    for (uint32_t i = 0; i < v->len; i++) {
+        unsigned char c = p[i];
+        if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+            c == '-' || c == ';' || c == '/' || c == '?' || c == ':' || c == '@' || c == '&' ||
+            c == '=' || c == '+' || c == '$' || c == ',' || c == '.' || c == '!' || c == '~' ||
+            c == '*' || c == '\'' || c == '(' || c == ')') {
+            wr_byte(w, (char)c);
+        } else {
+            wr_byte(w, '%');
+            wr_byte(w, hd[c >> 4]);
+            wr_byte(w, hd[c & 0xf]);
+        }
+    }
+}
+
 /* Explicit tag, verbatim URI form ("!<tag:…> "). Never skipped: a
  * recorded tag always re-emits (implied-by-style skipping made the
  * roundtrip byte-unstable: plain+!!str and ""+!!str collided). */
@@ -567,13 +607,15 @@ static void emit_tag(yep_writer* w, const yep_dnode* n) {
     if (tdec.len > 0 && tdec.p[0] == '!') {
         /* already a shorthand ("!ruby/object:K", "!foo"): verbatim —
          * the !<...> wrapper is for verbatim URIs only */
-        wr_put(w, (const char*)tdec.p, tdec.len);
+        yep_view rest = {tdec.p + 1, tdec.len - 1};
+        wr_byte(w, '!');
+        wr_tag_uri(w, &rest);
         wr_byte(w, ' ');
         return;
     }
     wr_byte(w, '!');
     wr_byte(w, '<');
-    wr_put(w, (const char*)tdec.p, tdec.len);
+    wr_tag_uri(w, &tdec);
     wr_byte(w, '>');
     wr_byte(w, ' ');
 }
@@ -587,7 +629,7 @@ static void emit_props_tail(yep_writer* w, const yep_dnode* n) {
         yep_view tdec2 = wv(w, n->tag);
         wr_byte(w, '!');
         wr_byte(w, '<');
-        wr_put(w, (const char*)tdec2.p, tdec2.len);
+        wr_tag_uri(w, &tdec2);
         wr_byte(w, '>');
     }
     if (n->anchor.len > 0) {

data/vendor/libyeptris/src/yeptris/events/values.c

@@ -19,6 +19,7 @@
 #include "../../include/yeptris/values.h"
 #include "../common/simd_text.h"
 #include "../dom/dom.h"
+#include "../encoding/encoding.h"
 #include "../memory/allocator.h"
 #include "../parse/engine.h"
 #include "../parse/numbers.h"
@@ -377,54 +378,91 @@ static int drain_json_route(const char* yaml, size_t len, yep_value_ctx** out) {
  * record array + arena, ownership moves to the caller. */
 int yep_values_from_input(const char* yaml, size_t len, int schema_compat, yep_value_ctx** out) {
     *out = NULL;
-    if (looks_strict_json(yaml, len)) {
-        int jrc = drain_json_route(yaml, len, out);
-        if (jrc <= 0) {
-            return jrc == 0 ? 0 : -1;
+    /* The encoding gate the parse entry owns (parse.c): the marshal/
+     * visit / value drains must not feed raw UTF-16/32 bytes to the
+     * engine while yeptris_parse accepts them — the nightly's marshal
+     * crasher (a UTF-16BE doc whose raw bytes contain "-s"). */
+    yep_encoding enc = YEP_ENC_UNKNOWN;
+    size_t bom = yep_bom_sniff((const unsigned char*)yaml, len, &enc);
+    const char* data = yaml + bom;
+    size_t data_len = len - bom;
+    unsigned char* transcoded = NULL;
+    const yep_allocator* sys = yep_system_allocator();
+    if (enc == YEP_ENC_UTF16LE || enc == YEP_ENC_UTF16BE || enc == YEP_ENC_UTF32LE ||
+        enc == YEP_ENC_UTF32BE) {
+        size_t tlen = 0;
+        size_t terr = 0;
+        int rc = yep_transcode_to_utf8(sys, enc, (const unsigned char*)data, data_len, &transcoded,
+                                       &tlen, &terr);
+        if (rc != 0) {
+            return -2;
+        }
+        size_t pverr = 0;
+        if (!yep_printable_validate(transcoded, tlen, &pverr)) {
+            yep_free(sys, transcoded);
+            return -2;
+        }
+        data = (const char*)transcoded;
+        data_len = tlen;
+    }
+    int prc_final = -2;
+    do {
+        if (looks_strict_json(data, data_len)) {
+            int jrc = drain_json_route(data, data_len, out);
+            if (jrc <= 0) {
+                prc_final = (jrc == 0) ? 0 : -1;
+                break;
+            }
+            /* fall through: engine */
+        }
+        yep_engine* eng = yep_engine_create(yep_system_allocator());
+        if (eng == NULL) {
+            return -1;
+        }
+        yep_engine_set_resolver(eng,
+                                schema_compat ? yep_resolver_compat11() : yep_resolver_core12());
+        if (schema_compat) {
+            yep_engine_set_compat_grammar(eng, 1); /* libyaml grammar parity
+                                                    * (the value drains ride the
+                                                    * same compat contract) */
         }
-        /* fall through: engine */
-    }
-    yep_engine* eng = yep_engine_create(yep_system_allocator());
-    if (eng == NULL) {
-        return -1;
-    }
-    yep_engine_set_resolver(eng, schema_compat ? yep_resolver_compat11() : yep_resolver_core12());
-    if (schema_compat) {
-        yep_engine_set_compat_grammar(eng, 1); /* libyaml grammar parity
-                                                * (the value drains ride the
-                                                * same compat contract) */
-    }
 
-    yep_value_ctx* c = ctx_create();
-    if (c == NULL) {
-        yep_engine_destroy(eng);
-        return -1;
-    }
-    yep_rec_store store;
-    yep_rec_init(&store);
+        yep_value_ctx* c = ctx_create();
+        if (c == NULL) {
+            yep_engine_destroy(eng);
+            return -1;
+        }
+        yep_rec_store store;
+        yep_rec_init(&store);
 
-    int prc = -2;
-    yep_sink sink = {.on_event = yep_rec_on_event,
-                     .ctx = &store,
-                     .on_flow_build = NULL,
-                     .on_flow_commit = NULL,
-                     .on_flow_rollback = NULL,
-                     .on_block_pair = NULL,
-                     .on_block_open = NULL,
-                     .on_block_item = NULL};
-    /* strict JSON carries no anchors: no nametab reserve needed */
-    if (yep_engine_run(eng, yaml, len, &sink) == 0 && transform(c, &store) == 0) {
-        prc = 0;
-    } else if (c->oom) {
-        prc = -1;
-    }
-    yep_engine_destroy(eng);
-    yep_rec_free(&store);
-    if (prc != 0) {
-        yep_value_ctx_free(c);
-        return prc == -1 ? -1 : -2;
+        int prc = -2;
+        yep_sink sink = {.on_event = yep_rec_on_event,
+                         .ctx = &store,
+                         .on_flow_build = NULL,
+                         .on_flow_commit = NULL,
+                         .on_flow_rollback = NULL,
+                         .on_block_pair = NULL,
+                         .on_block_open = NULL,
+                         .on_block_item = NULL};
+        /* strict JSON carries no anchors: no nametab reserve needed */
+        if (yep_engine_run(eng, data, data_len, &sink) == 0 && transform(c, &store) == 0) {
+            prc = 0;
+        } else if (c->oom) {
+            prc = -1;
+        }
+        yep_engine_destroy(eng);
+        yep_rec_free(&store);
+        if (prc != 0) {
+            yep_value_ctx_free(c);
+            break;
+        }
+        prc_final = ctx_finalize(c, out) == 0 ? 0 : -1;
+    } while (0);
+    yep_free(sys, transcoded);
+    if (prc_final != 0 && prc_final != -1) {
+        return -2;
     }
-    return ctx_finalize(c, out) == 0 ? 0 : -1;
+    return prc_final;
 }
 
 static YeptrisStatus map_status(int rc) {

data/vendor/libyeptris/src/yeptris/parse/engine.c

@@ -3112,6 +3112,17 @@ static int e_parse_value(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
              * fixture shape) */
             (vctx == YEP_CTX_VALUE_LINE && (li.first == '|' || li.first == '>') &&
              li.indent == floor_col)) {
+            /* an empty-key ':' line cannot be a pending value's
+             * content — libyaml errors ("did not find expected key";
+             * the nightly's "- &a\n :" byte-instability crasher).
+             * The same-line empty-key law lives in the shape arms. */
+            if (li.first == ':') {
+                size_t at2 = e->pos + li.indent + 1;
+                if (at2 >= e->len || e->p[at2] == ' ' || e->p[at2] == '\t' || e->p[at2] == '\n' ||
+                    e->p[at2] == '\r') {
+                    return e_fail(e, YEP_ERR_UNEXPECTED, e->pos + li.indent);
+                }
+            }
             e->pos += li.indent;
             if (++e->rec >= e->max_depth) {
                 e->rec--;

metadata

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