yeptris 0.6.10.1 → 0.6.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 911e4f9b49027d9a90c269d485980d025040866830e8138d6dbb7e573e6e49ca
-  data.tar.gz: c48b0a777f5e7f7f3771bdb44661f7a5d3f11e3713895b3d0029847ce56cb7ef
+  metadata.gz: fab04bdd5f0236d59b5d139d410c095d9c99c8aacccaa18c464324c58b0eef33
+  data.tar.gz: 9ba0ca96dd534843e8238921f3de634c7f18b051f90b3bde901be74b950a6403
 SHA512:
-  metadata.gz: cf0d8e4fb6c0833b3a1232293cc55ce4e51e4a88af05b84eee940288c197eaf2c837c3f75382cdcb643a64680869e314ae09b3076b711953cd40cd244535aedb
-  data.tar.gz: 3276f1b2af11b03a225b0b52bc7bc38982c38a65fe50b3890ab7a02d9d8c202a7e2703efc8879b8d96e9f51483e01115961c263fc89093acf01733ca71f0d454
+  metadata.gz: 2281939709069aaf555ed5df307cc613b304ad236d7c3fc13cca8a4fc28a0ee8ca35f41d7dd3b46c9db71a8a088d90565e4ccfd7aa25c4512a83d46b41bddd79
+  data.tar.gz: 9731da1240594c945e1eba4f7eef86e3ec10556c23ab0c84617b2109c17c2c08e08d2c64c5cd558103c07abe2ef93da00735ca6c42703e61fbae4eac7a0ad64c

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.10.1".freeze
+  VERSION = "0.6.11.1".freeze
   # The error hierarchy lives in THIS file (the parent namespace's
   # own file): nested constants do not trigger a parent-constant
   # autoload, and the law forbids internal requires — defining the

data/vendor/libyeptris/CMakeLists.txt

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

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

@@ -39,6 +39,11 @@ YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument handle,
         return 0;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
     em.w.p = NULL;
     em.w.last = 0;
@@ -60,13 +65,20 @@ YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument handle,
     if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
         return 0;
     }
+    em.w.sc_dec = (uint8_t*)malloc(em.doc->dom->ncount > 0 ? em.doc->dom->ncount : 1);
+    if (em.w.sc_dec == NULL) {
+        yep_nametab_free(&em.canon_names);
+        return 0;
+    }
     size_t need = yep_emit_run(&em, 1);
     if (buf == NULL || cap < need + 1) {
+        free(em.w.sc_dec);
         yep_nametab_free(&em.canon_names);
         return need;
     }
     em.w.p = buf;
     size_t wrote = yep_emit_run(&em, 0);
+    free(em.w.sc_dec);
     yep_nametab_free(&em.canon_names);
     buf[wrote] = '\0';
     return wrote;
@@ -82,6 +94,11 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
         return NULL;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
     em.w.p = NULL;
     em.w.last = 0;
@@ -103,13 +120,41 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
     if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
         return NULL;
     }
-    size_t need = yep_emit_run(&em, 1);
-    char* out = malloc(need + 1);
+    /* #352 slice 2: ONE wet pass into a growable buffer — the dry
+     * exact-sizing pass measured 0.54-0.73x of this route on CI-fresh
+     * runners (the emit-split table's 2p/1p column). The estimate
+     * starts at the input size (+64) and doubles on demand; a final
+     * shrink-to-fit keeps the returned allocation tight. No dry pass,
+     * so no decisions table. */
+    size_t est = em.doc->dom->input_len + 64;
+    if (est < 256) {
+        est = 256;
+    }
+    char* out = (char*)malloc(est);
     if (out == NULL) {
+        yep_nametab_free(&em.canon_names);
         return NULL;
     }
     em.w.p = out;
+    em.w.cap = est;
+    em.w.grow = 1;
     size_t wrote = yep_emit_run(&em, 0);
+    em.w.grow = 0;
+    /* wr_grow reallocs through w->p — the local `out` is stale after
+     * any growth; every post-run touch goes through the writer's
+     * pointer (the first round's abort was exactly this aliasing) */
+    out = em.w.p;
+    if (em.w.oom) {
+        free(out);
+        yep_nametab_free(&em.canon_names);
+        return NULL;
+    }
+    if (wrote + 1 < em.w.cap) {
+        char* tight = (char*)realloc(out, wrote + 1);
+        if (tight != NULL) {
+            out = tight;
+        }
+    }
     yep_nametab_free(&em.canon_names);
     out[wrote] = '\0';
     if (len != NULL) {
@@ -123,6 +168,11 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
         return NULL;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
     em.w.p = NULL;
     em.w.last = 0;
@@ -168,6 +218,11 @@ YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument handle, size_t* len,
         return NULL;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
     em.w.p = NULL;
     em.w.last = 0;
@@ -210,6 +265,11 @@ char* yep_serialize_json_compact(const yeptris_document* doc, size_t* len) {
         return NULL;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = doc;
     em.w.p = NULL;
     em.w.last = 0;
@@ -252,6 +312,11 @@ char* yep_serialize_json_pretty(const yeptris_document* doc, size_t* len) {
         return NULL;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = doc;
     em.w.p = NULL;
     em.w.last = 0;
@@ -307,6 +372,11 @@ YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument handle,
         return 0;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
     em.w.p = NULL;
     em.w.last = 0;

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

@@ -64,6 +64,24 @@ static void wr_col_update(yep_writer* w, const char* p, uint32_t n) {
     w->col += (int)n;
 }
 
+static void wr_grow(yep_writer* w, size_t need) {
+    if (w->oom || w->p == NULL) {
+        w->oom = w->p == NULL;
+        return;
+    }
+    size_t want = w->len + need + 1;
+    if (want < w->cap * 2) {
+        want = w->cap * 2;
+    }
+    char* np = (char*)realloc(w->p, want);
+    if (np == NULL) {
+        w->oom = 1;
+        return;
+    }
+    w->p = np;
+    w->cap = want;
+}
+
 static void wr_put(yep_writer* w, const char* p, uint32_t n) {
     if (n > 0) {
         w->last = p[n - 1];
@@ -73,6 +91,13 @@ static void wr_put(yep_writer* w, const char* p, uint32_t n) {
         w->len += n;
         return;
     }
+    if (w->grow && w->len + n > w->cap) {
+        wr_grow(w, n);
+    }
+    if (w->oom) {
+        w->len += n; /* keep counting: the caller fails on oom */
+        return;
+    }
     memcpy(w->p + w->len, p, n);
     w->len += n;
     wr_maybe_flush(w);
@@ -89,6 +114,13 @@ static void wr_byte(yep_writer* w, char c) {
         w->len++;
         return;
     }
+    if (w->grow && w->len + 1 > w->cap) {
+        wr_grow(w, 1);
+    }
+    if (w->oom) {
+        w->len++;
+        return;
+    }
     w->p[w->len] = c;
     w->len++;
     wr_maybe_flush(w);
@@ -275,21 +307,16 @@ static void emit_canonical_scalar(yep_writer* w, const yep_dnode* n) {
     }
 }
 
-static void emit_scalar(yep_writer* w, const yep_dnode* n, int parent_col, int as_key) {
-    yep_view vdec = wv(w, n->value);
-    const char* p = (const char*)vdec.p;
-    uint32_t len = vdec.len;
-    if (w->canonical || w->json) {
-        emit_canonical_scalar(w, n);
-        return;
-    }
-    /* p may be NULL for an empty view; memchr(NULL, .., 0) is UB by
-     * the nonnull attribute even though it reads nothing */
+/* The fidelity-mode emission route for one scalar (#352): the dry
+ * pass derives it exactly once; the wet pass consumes the recorded
+ * byte and skips the multiline/blockable/safety analysis entirely. */
+enum { YEP_SC_NOTHING = 0, YEP_SC_PLAIN, YEP_SC_SQ, YEP_SC_DQ, YEP_SC_LITERAL };
+#define YEP_SC_MEMO_MIN 32u /* bytes; derive-below, memoize-above */
+
+static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key, uint8_t sty_in) {
     int multiline = (len > 0 && memchr(p, '\n', len) != NULL);
     int blockable = 0;
     if (multiline && !as_key) {
-        /* A block whose body is all whitespace parses back empty, and a
-         * raw CR re-parses as a break — both emit double-quoted. */
         int allws = 1;
         int has_cr = 0;
         for (uint32_t i = 0; i < len; i++) {
@@ -302,68 +329,88 @@ static void emit_scalar(yep_writer* w, const yep_dnode* n, int parent_col, int a
         }
         blockable = !allws && !has_cr;
     }
-    int sty = n->style;
+    uint8_t sty = sty_in;
     if (sty == 4 || sty == 5) {
         if (multiline && as_key) {
-            emit_dq(w, p, len); /* keys stay inline: no block scalars */
-            return;
+            return YEP_SC_DQ;
         }
         if (multiline && blockable) {
-            emit_literal(w, n, parent_col);
-            return;
+            return YEP_SC_LITERAL;
         }
         if (multiline) {
-            emit_dq(w, p, len);
-            return;
+            return YEP_SC_DQ;
         }
         if (len == 0) {
-            emit_dq(w, p, len); /* an explicitly-empty block scalar is
-                                   the empty STRING — a bare empty would
-                                   re-read as null (2G84#3, K858) */
-            return;
+            return YEP_SC_DQ;
         }
-        sty = 1; /* a chomp-stripped block is plain bytes: re-emit plain */
+        sty = 1;
     }
     switch (sty) {
-    case 1: /* plain */
+    case 1:
         if (len == 0) {
-            if (as_key) {
-                emit_dq(w, p, len); /* empty keys must stay visible */
-            }
-            break; /* an empty plain value emits as nothing (libyaml's
-                       null rendering, issue #290) */
+            return as_key ? YEP_SC_DQ : YEP_SC_NOTHING;
         }
-        if ((as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len))) {
-            wr_put(w, p, len);
-        } else if (!multiline) {
-            /* libyaml parity: a scalar that must be quoted but needs no
-             * escapes (digit-leading strings like "5014", indicator
-             * leads) single-quotes — double quotes are for text that
-             * actually requires escapes (issue #95's matrix) */
-            int clean = 1;
+        if (as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len)) {
+            return YEP_SC_PLAIN;
+        }
+        if (!multiline) {
             for (uint32_t i = 0; i < len; i++) {
                 if ((unsigned char)p[i] < 0x20 || (unsigned char)p[i] == 0x7f) {
-                    clean = 0;
-                    break;
+                    return YEP_SC_DQ;
                 }
             }
-            if (clean) {
-                emit_sq(w, p, len);
-            } else {
-                emit_dq(w, p, len);
-            }
-        } else {
-            emit_dq(w, p, len);
+            return YEP_SC_SQ;
         }
-        break;
-    case 2: /* single */
-        if (!multiline) {
-            emit_sq(w, p, len);
+        return YEP_SC_DQ;
+    case 2:
+        return multiline ? YEP_SC_DQ : YEP_SC_SQ;
+    default:
+        return YEP_SC_DQ;
+    }
+}
+
+static void emit_scalar(yep_writer* w, const yep_dnode* n, int parent_col, int as_key) {
+    yep_view vdec = wv(w, n->value);
+    const char* p = (const char*)vdec.p;
+    uint32_t len = vdec.len;
+    if (w->canonical || w->json) {
+        emit_canonical_scalar(w, n);
+        return;
+    }
+    (void)0;
+    uint8_t route;
+    /* The memo pays only for LONG scalars: the derive cost scales with
+     * len (safety walk, quote scans) while the memo is a fixed store +
+     * cold load — on the short scalars of table-shaped documents the
+     * memo measured SLOWER than re-deriving (the #357 first artifact:
+     * json-users -36%, scalar-heavy +24%). Below the threshold both
+     * passes derive; the consumption-order index covers only the
+     * memoized long scalars, in visit order either way. */
+    if (w->sc_dec != NULL && len >= YEP_SC_MEMO_MIN) {
+        if (w->dry) {
+            route = sc_route(w, p, len, as_key, n->style);
+            w->sc_dec[w->sc_i] = route;
         } else {
-            emit_dq(w, p, len);
+            route = w->sc_dec[w->sc_i];
         }
+        w->sc_i++;
+    } else {
+        route = sc_route(w, p, len, as_key, n->style);
+    }
+    switch (route) {
+    case YEP_SC_NOTHING:
+        break; /* an empty plain value emits as nothing (libyaml's null
+                  rendering, issue #290) */
+    case YEP_SC_PLAIN:
+        wr_put(w, p, len);
+        break;
+    case YEP_SC_SQ:
+        emit_sq(w, p, len);
+        break;
+    case YEP_SC_LITERAL:
+        emit_literal(w, n, parent_col);
         break;
-    default: /* double, literal-as-key, folded-as-key, any */
+    default:
         emit_dq(w, p, len);
         break;
     }
@@ -694,6 +741,7 @@ size_t yep_emit_run(yep_emitter* em, int dry) {
     w->flushed = 0;
     w->sink_aborted = 0;
     w->col = 0;
+    w->sc_i = 0;
     yep_nametab_clear(&em->canon_names);
     if (w->json) {
         /* JSON has no multi-document streams and no document marker */

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

@@ -40,6 +40,21 @@ typedef struct yep_writer {
     int col;                                    /* current output column (wr_* maintains) */
     const char* sv_input;                       /* compact-view decode bases (dom regions) */
     const char* sv_arena;
+    /* #352: per-scalar route decisions, derived once in the dry
+     * sizing pass and consumed by the wet write pass (one byte per
+     * scalar, indexed by consumption order; NULL = derive per pass) */
+    uint8_t* sc_dec;
+    uint32_t sc_i;
+    /* #352 slice 2: the growable single-pass route — the exact-sizing
+     * dry pass measured 0.54-0.73x of the one-pass stream route on
+     * CI-fresh runners, so serialize_ex writes wet into a buffer that
+     * doubles on demand (cap/grow), like the streaming window. The
+     * fixed-buffer routes keep grow=0 and today's trust-the-count
+     * behavior. oom marks a failed growth: writes stop touching memory
+     * but the byte count keeps running so callers can fail cleanly. */
+    size_t cap;
+    int grow;
+    int oom;
 } yep_writer;
 
 typedef struct yep_emitter {

metadata

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