yeptris 0.6.35.2-aarch64-linux → 0.6.37.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82fd76f8174195b1c5251a4d292b8da3604a0e91c396efb570ea18414ba862c1
-  data.tar.gz: 4cccd65148e639051cc851b5a12e688ad339cccf09f05eddecbc90991a6ac345
+  metadata.gz: 0b9695f8f9e37a623dbe567e66018e50f6afb6ae479d0a0f42218ed2ca011dc8
+  data.tar.gz: '08c35c1d8e5eb686e0f573272bc9bf20cf9b17ab060a502c0d1de8c83e4a6e4d'
 SHA512:
-  metadata.gz: 815616106e14b2f9d396bf382d306e9431485ce53415d3f78c2bb159ae2769d20e576e1488f6fe5977959c53275c5cff37ff78d53dd05414f1695fa96072cb9e
-  data.tar.gz: c49172b62d9f7914eb2221485d3dcb028be6aeb1c200be553cd1b656359893c3c4e8c97bc9715109eaf454fe84be48380e2e41f321bdbccee46c5a832b7a15ce
+  metadata.gz: 4c3dc61e302319370012a822c4e813df1c6f8fcb90b5a07719db5a824c7f80dcba2e90567d451ca560e71c92c4eebbfa93f869ff452ef243722a24c8f05c3e04
+  data.tar.gz: b3f3771a5d06f58c2e404af154cca6257dab478a1ad19b8c59515b0573532c599d2e4bdc4e64dec4c4c6b801c4f7e9874b295a52e911b9e57d60aa3764c3b5d3

data/lib/yeptris/document.rb

@@ -202,6 +202,17 @@ class Yeptris::Document
     Yeptris::FFI::Owned.string(Yeptris::FFI.yeptris_serialize_json_ex(@c_ptr, len, 1), len)
   end
 
+  # JSON.pretty_generate's shape; nil indent rides the engine default
+  # (two spaces), any other String's bytes ride verbatim per depth
+  def serialize_json_pretty(indent = nil)
+    ensure_alive!
+    len = ::FFI::MemoryPointer.new(:size_t)
+    data = indent&.b
+    Yeptris::FFI::Owned.string(
+      Yeptris::FFI.yeptris_serialize_json_pretty(@c_ptr, len, data, data ? data.bytesize : 0), len
+    )
+  end
+
   def serialize_json
     ensure_alive!
     len = ::FFI::MemoryPointer.new(:size_t)

data/lib/yeptris/ffi.rb

@@ -276,6 +276,14 @@ module Yeptris
       false
     end
 
+    # pretty JSON generation (JSON.pretty_generate's shape); the JSON
+    # surface feature-detects via the @missing convention below (the
+    # deferred stub records the miss at attach, so a begin/rescue
+    # never fires)
+    attach_function :yeptris_serialize_json_pretty,
+                    %i[yeptris_document pointer pointer size_t], :pointer
+    JSON_PRETTY = !(@missing ||= []).include?(:yeptris_serialize_json_pretty)
+
     # CBOR (RFC 8949, TODO.cbor): absent on libraries before the
     # codec's release — the CBOR module feature-detects
     attach_function :yeptris_cbor_decode, %i[pointer size_t uint32 yeptris_status_out],

data/lib/yeptris/json.rb

@@ -367,7 +367,7 @@ module Yeptris
     # and null stay plain), Symbols become their name.
     class DumpError < Error; end
 
-    def dump(obj)
+    def dump(obj, pretty: false, indent: "  ")
       parts = String.new(encoding: Encoding::BINARY,
                          capacity: 12 * 16) # 12-byte entries, appended in place
       blob = String.new(encoding: Encoding::BINARY)
@@ -377,7 +377,17 @@ module Yeptris
       # FFI passes String args BY REFERENCE — no MemoryPointer copies
       rc = doc.build_entries(parts, parts.bytesize / 12, blob, blob.bytesize)
       raise DumpError, "document_build failed: #{rc}" unless rc == ::Yeptris::FFI::OK
-      out = ::Yeptris::FFI::JSON_EX ? doc.serialize_json_compact : doc.serialize_json
+      out =
+        if pretty
+          unless ::Yeptris::FFI::JSON_PRETTY
+            raise DumpError, "pretty JSON needs a libyeptris with yeptris_serialize_json_pretty"
+          end
+          doc.serialize_json_pretty(indent)
+        elsif ::Yeptris::FFI::JSON_EX
+          doc.serialize_json_compact
+        else
+          doc.serialize_json
+        end
       # JSON.generate emits no trailing newline (the document writer does)
       out.end_with?("\n") ? out[0, out.bytesize - 1] : out
     ensure

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.35.2".freeze
+  VERSION = "0.6.37.0".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.35
+    VERSION 0.6.37
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

data/vendor/libyeptris/src/include/yeptris/json.h

@@ -38,6 +38,16 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument doc, size_t* len);
  * compact == 0 is byte-identical to yeptris_serialize_json. */
 YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument doc, size_t* len, int compact);
 
+/* The pretty variant: JSON.pretty_generate's shape — one entry per
+ * line, ": " after keys, ",\n" + indent between entries, empty
+ * collections inline. indent/indent_len select the indent unit
+ * (NULL/0 = two spaces; the bytes are written verbatim per depth).
+ * Memory: returns a malloc'd NUL-terminated buffer (caller frees)
+ * with *len (may be NULL) set, or NULL on a NULL document /
+ * allocation failure / zero documents. */
+YEPTRIS_API char* yeptris_serialize_json_pretty(YeptrisDocument doc, size_t* len,
+                                                const char* indent, size_t indent_len);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -308,6 +308,14 @@ YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument handle, size_t* len,
     return out;
 }
 
+YEPTRIS_API char* yeptris_serialize_json_pretty(YeptrisDocument handle, size_t* len,
+                                                const char* indent, size_t indent_len) {
+    if (handle == NULL) {
+        return NULL;
+    }
+    return yep_serialize_json_pretty_ex((const yeptris_document*)handle, len, indent, indent_len);
+}
+
 char* yep_serialize_json_compact(const yeptris_document* doc, size_t* len) {
     if (doc == NULL) {
         return NULL;
@@ -364,9 +372,17 @@ char* yep_serialize_json_compact(const yeptris_document* doc, size_t* len) {
 }
 
 char* yep_serialize_json_pretty(const yeptris_document* doc, size_t* len) {
+    return yep_serialize_json_pretty_ex(doc, len, NULL, 2);
+}
+
+char* yep_serialize_json_pretty_ex(const yeptris_document* doc, size_t* len, const char* indent,
+                                   size_t indent_len) {
     if (doc == NULL) {
         return NULL;
     }
+    if (yep_doc_dom((yeptris_document*)doc) == NULL) { /* #342 lazy */
+        return NULL;
+    }
     yep_emitter em;
     em.w.sc_dec = NULL;
     em.w.sc_i = 0;
@@ -386,6 +402,8 @@ char* yep_serialize_json_pretty(const yeptris_document* doc, size_t* len) {
     em.w.json_compact = 0;
     em.w.json_pretty = 1;
     em.w.pretty_depth = 0;
+    em.w.json_indent = indent;
+    em.w.json_indent_len = indent == NULL ? 2 : (int)indent_len;
     em.w.best_width = 0;
     em.w.col = 0;
     em.w.sv_input = doc->dom->input_base;

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

@@ -139,6 +139,18 @@ static void wr_indent(yep_writer* w, int depth) {
     }
 }
 
+/* json_pretty's per-depth indent: the default two spaces per level,
+ * or depth copies of the caller's unit (json.h pretty entry). */
+static void wr_pretty_indent(yep_writer* w, int depth) {
+    if (w->json_indent == NULL) {
+        wr_indent(w, depth * 2);
+        return;
+    }
+    for (int i = 0; i < depth; i++) {
+        wr_put(w, w->json_indent, (uint32_t)w->json_indent_len);
+    }
+}
+
 static void emit_dq(yep_writer* w, const char* p, uint32_t n) {
     wr_byte(w, '"');
     uint32_t run = 0;
@@ -899,9 +911,9 @@ static void emit_flow(yep_emitter* em, uint32_t id) {
     int flow_indent = w->col;
     if (w->json_pretty && n->count > 0) {
         w->pretty_depth++;
-        flow_indent = w->pretty_depth * 2; /* 2 spaces per level */
         wr_byte(w, '\n');
-        wr_indent(w, flow_indent);
+        wr_pretty_indent(w, w->pretty_depth);
+        flow_indent = w->col;
     }
     uint32_t child = n->first_child;
     uint32_t idx = 0;
@@ -913,7 +925,7 @@ static void emit_flow(yep_emitter* em, uint32_t id) {
              * re-indent to the opening bracket's column */
             if (w->json_pretty) {
                 wr_put(w, ",\n", 2);
-                wr_indent(w, w->pretty_depth * 2);
+                wr_pretty_indent(w, w->pretty_depth);
             } else if (w->json_compact) {
                 wr_byte(w, ',');
             } else if (w->best_width > 0 && w->col > w->best_width) {
@@ -964,7 +976,7 @@ static void emit_flow(yep_emitter* em, uint32_t id) {
     }
     if (w->json_pretty && idx > 0) {
         wr_byte(w, '\n');
-        wr_indent(w, (w->pretty_depth - 1) * 2);
+        wr_pretty_indent(w, w->pretty_depth - 1);
         w->pretty_depth--;
     }
     wr_byte(w, map ? '}' : ']');

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

@@ -35,6 +35,8 @@ typedef struct yep_writer {
     int json_compact;                           /* json-c to_json_string: no padding spaces */
     int json_pretty;                            /* json-c PRETTY: 2-space indent, per-entry lines */
     int pretty_depth;                           /* json_pretty nesting level (indent = 2*depth) */
+    const char* json_indent;                    /* json_pretty indent unit; NULL = 2 spaces */
+    int json_indent_len;                        /* json_pretty unit byte length */
     int best_width;                             /* 13B: 0 = default 80; flow lines wrap after a
                                                  * value past this width */
     int col;                                    /* current output column (wr_* maintains) */
@@ -79,5 +81,7 @@ size_t yep_emit_run(yep_emitter* em, int dry);
  * nesting level, one entry per line. */
 char* yep_serialize_json_compact(const yeptris_document* doc, size_t* len);
 char* yep_serialize_json_pretty(const yeptris_document* doc, size_t* len);
+char* yep_serialize_json_pretty_ex(const yeptris_document* doc, size_t* len, const char* indent,
+                                   size_t indent_len);
 
 #endif /* YEP_EMIT_WRITER_H */

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

@@ -815,7 +815,17 @@ static int strict_dup_scan(const yep_value_ctx* c) {
             }
             continue;
         }
-        yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0, "duplicate key in object");
+        /* name the key like the tape walk's message (json 3 names it
+         * too): the arena bytes are the text for the str-like kinds,
+         * which is every JSON key */
+        if (k.kind == YEP_V_STR || k.kind == YEP_V_TIMESTAMP || k.kind == YEP_V_ALIAS ||
+            k.kind == YEP_V_ANCHOR) {
+            yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
+                          "duplicate key \"%.*s\" in JSON object", (int)k.len,
+                          k.len ? c->arena + k.off : "");
+        } else {
+            yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0, "duplicate key in object");
+        }
         rc = 1;
     }
     for (size_t j = 0; j < depth; j++) {

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

@@ -555,9 +555,15 @@ static int e_flush_q_value(yep_engine* e) {
  * this pop the stack keeps a stale entry and the outer pair's null
  * flushes inside the wrong map (the nightly's run 38387614146). */
 static int e_pair_value_done(yep_engine* e, yep_ctx ctx, uint16_t key_col) {
+    /* the pair's own level, BEFORE its value parse: the value may open
+     * deeper frames ("? a:\n   ? b<EOF>") and a post-parse depth read
+     * then matches the DEEPER pair's pending slot, popping the wrong
+     * entry and stranding the outer null (the nightly's round 24,
+     * crash-bcc0f52c) */
+    int pre_depth = e->depth;
     int rc = e_parse_value(e, YEP_CTX_AFTER_COLON, key_col);
     if (rc >= 0 && ctx == YEP_CTX_AFTER_Q && e->qmd_n > 0 &&
-        e->depth == e->qmd_stack[e->qmd_n - 1]) {
+        pre_depth == e->qmd_stack[e->qmd_n - 1]) {
         e->qmd_n--; /* the inline value resolved the innermost '?' pending */
     }
     return rc;
@@ -1173,6 +1179,14 @@ static yep_view e_resolve_tag_raw(yep_engine* e, yep_view tag) {
         yep_view v = {tag.p + 2, tag.len - 3};
         return v;
     }
+    /* the BARE '!' is the non-specific tag and is exempt from %TAG
+     * directives (spec 7.3.3): it stays '!' here, and the plain-scalar
+     * drop happens at emit_now (the nightly's round 22, crash-d6be3347:
+     * '%TAG ! ...' + '- ! tag:clarkevans.com,2002:' resolved the
+     * non-specific tag through the directive where libyaml drops it) */
+    if (tag.len == 1 && tag.p[0] == '!') {
+        return tag;
+    }
     /* longest matching handle wins */
     int best = -1;
     uint32_t best_len = 0;
@@ -1261,6 +1275,27 @@ static void e_props(yep_engine* e, yep_view* anchor, yep_view* tag) {
                 e_fail(e, YEP_ERR_UNEXPECTED, e->pos);
                 return;
             }
+            /* The flow-follower colon law (the nightly's round 29,
+             * crash-47eb4054): a name ending at a riding colon whose
+             * follower is a FLOW collection un-consumes the colon.
+             * libyaml ACCEPTS "&k2: [1,\n2]" — the anchor names the
+             * implicit-null KEY and the flow is the value — so the
+             * riding law (2SXE) must yield exactly where its result
+             * is observable in the differential; the plain-led twins
+             * keep it (libyaml rejects those: "&a: key: v", W5VH's
+             * value position — suite-VALID, ledgered). The colon
+             * re-lexes as the key indicator and the existing colon
+             * arm builds the anchored null key. */
+            if (e->p[e->pos - 1] == ':') {
+                size_t t = e->pos;
+                while (t < e->len && (e->p[t] == ' ' || e->p[t] == '\t')) {
+                    t++;
+                }
+                if (t < e->len && (e->p[t] == '[' || e->p[t] == '{')) {
+                    anchor->len -= 1;
+                    e->pos -= 1;
+                }
+            }
             if (e->pos < e->len && e->p[e->pos] == '#') {
                 /* the name ends at a blank or flow indicator; a glued
                  * '#' is junk on the name (libyaml: "did not find
@@ -3628,6 +3663,15 @@ static int e_node(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
         while (e->pos < e->len && e->p[e->pos] != ':') {
             e->pos++;
         }
+        if (e->pos >= e->len) {
+            /* EOF without the ':': the explicit-key pair's value never
+             * came ("? b<EOF>") — the pending stays armed and the
+             * stream-end flush completes it at the deepest open map
+             * (the nightly's round 24, crash-bcc0f52c); popping here
+             * resolved a pair that has no value and stranded the OUTER
+             * pending's null in the wrong map */
+            return 0;
+        }
         e->pos++; /* past ':' */
         return e_pair_value_done(e, ctx, key_col);
     }
@@ -4106,55 +4150,82 @@ static yep_norm_tok norm_step(yep_norm_ctx* c, const char* p, size_t len, size_t
         return t;
     }
     if (c->quote != 0) {
-        /* NEL folds inside quotes too; LS/PS stay raw content */
-        if (nel) {
-            t.n = 2;
-            t.fold_off = 0;
-            t.fold_len = 2;
-            return t;
-        }
-        if (lps) {
-            t.n = 3;
-            return t;
-        }
-        if (c->quote == '\'') {
-            if (ch == '\'') {
-                if (i + 1 < len && p[i + 1] == '\'') {
-                    t.n = 2; /* '' escaped quote */
-                    return t;
-                }
-                c->quote = 0;
-            }
-            return t;
-        }
-        if (ch == '\\') {
-            /* the escape consumes the next byte — but a multibyte
-             * break under the escape still folds (an escaped break is
-             * a fold continuation, and the blind pass folded it) */
-            if (i + 1 >= len) {
+        /* A col-0 --- / ... marker RESCUES the quote: the parser ends
+         * the document at the marker (the post-cut reset says "the
+         * tail began at a --- line in a clean state"), so bytes after
+         * it are NOT quoted content. Whole-buffer runs must classify
+         * them the same way or the routes diverge: round 25 of the
+         * nightly (crash-27a77050) fed ">\n: '\n---\na<U+2029>" and
+         * the whole route kept the PS raw inside the never-closed
+         * quote while the chunked route (fresh probe after the cut)
+         * folded it — a plain scalar "a " vs "a". */
+        int rescue = (c->at_break && i + 2 < len && (ch == '-' || ch == '.') && p[i + 1] == ch &&
+                      p[i + 2] == ch &&
+                      (i + 3 >= len || p[i + 3] == ' ' || p[i + 3] == '\t' || p[i + 3] == '\n' ||
+                       p[i + 3] == '\r'));
+        if (rescue) {
+            c->quote = 0;
+        } else {
+            /* NEL folds inside quotes too; LS/PS stay raw content — but
+             * every break still arms the line-start state, or a col-0
+             * marker after a quoted newline is invisible (at_break was
+             * last armed OUTSIDE the quote) */
+            if (nel) {
+                t.n = 2;
+                t.fold_off = 0;
+                t.fold_len = 2;
+                c->at_break = 1;
                 return t;
             }
-            unsigned char nx = (unsigned char)p[i + 1];
-            if (nx == 0xC2 && i + 2 < len && (unsigned char)p[i + 2] == 0x85) {
+            if (lps) {
                 t.n = 3;
-                t.fold_off = 1;
-                t.fold_len = 2;
+                c->at_break = 1;
                 return t;
             }
-            if (nx == 0xE2 && i + 3 < len && (unsigned char)p[i + 2] == 0x80 &&
-                ((unsigned char)p[i + 3] & 0xFE) == 0xA8) {
-                t.n = 4;
-                t.fold_off = 1;
-                t.fold_len = 3;
+            if (ch == '\n' || (ch == '\r' && (i + 1 >= len || p[i + 1] != '\n'))) {
+                c->at_break = 1;
                 return t;
             }
-            t.n = 2;
+            c->at_break = 0;
+            if (c->quote == '\'') {
+                if (ch == '\'') {
+                    if (i + 1 < len && p[i + 1] == '\'') {
+                        t.n = 2; /* '' escaped quote */
+                        return t;
+                    }
+                    c->quote = 0;
+                }
+                return t;
+            }
+            if (ch == '\\') {
+                /* the escape consumes the next byte — but a multibyte
+                 * break under the escape still folds (an escaped break is
+                 * a fold continuation, and the blind pass folded it) */
+                if (i + 1 >= len) {
+                    return t;
+                }
+                unsigned char nx = (unsigned char)p[i + 1];
+                if (nx == 0xC2 && i + 2 < len && (unsigned char)p[i + 2] == 0x85) {
+                    t.n = 3;
+                    t.fold_off = 1;
+                    t.fold_len = 2;
+                    return t;
+                }
+                if (nx == 0xE2 && i + 3 < len && (unsigned char)p[i + 2] == 0x80 &&
+                    ((unsigned char)p[i + 3] & 0xFE) == 0xA8) {
+                    t.n = 4;
+                    t.fold_off = 1;
+                    t.fold_len = 3;
+                    return t;
+                }
+                t.n = 2;
+                return t;
+            }
+            if (ch == '"') {
+                c->quote = 0;
+            }
             return t;
         }
-        if (ch == '"') {
-            c->quote = 0;
-        }
-        return t;
     }
     if (c->in_verbatim) {
         if (ch == '>') {
@@ -4892,7 +4963,26 @@ static size_t step_scan(yep_stepstate* st) {
                                 st->bs_indent = (uint32_t)-1; /* root rule: markers only */
                             }
                         }
-                        if (st->saw_directive == 0 && i > 0 && !st->bs_open) {
+                        /* the line before a marker must not be a
+                         * directive-LOOKING line: the scan's quote
+                         * state can close a quote where the parser
+                         * reads content (or vice versa), so a %-led
+                         * line may ride an open quote the scan
+                         * believes in -- cutting then strands the
+                         * directive from its --- and the window
+                         * rejects it (the nightly's round 27,
+                         * crash-95bbd95f: "i\n\"\n...\n%TAG ! \"\n--- ").
+                         * The check is byte-level, independent of the
+                         * quote tracking's verdict. */
+                        int prev_pct = 0;
+                        if (i > 0) {
+                            size_t ls = i - 1; /* the break before the marker */
+                            while (ls > 0 && p[ls - 1] != '\n' && p[ls - 1] != '\r') {
+                                ls--;
+                            }
+                            prev_pct = p[ls] == '%';
+                        }
+                        if (st->saw_directive == 0 && i > 0 && !st->bs_open && !prev_pct) {
                             last_cut = i; /* interior document boundary */
                         }
                         st->saw_directive = 0; /* this --- owns the directives */
@@ -5450,10 +5540,14 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
                 }
             } else {
                 e->q_key_pending = 0;
-                e->q_value_pending = 0;
                 if (e->qmd_n > 0) {
                     e->qmd_n--; /* the ':' line supplied the innermost value */
                 }
+                /* the flag governs the WHOLE stack: deeper pendings
+                 * keep it up so their nulls still flush (the nightly's
+                 * round 24, crash-bcc0f52c — the hard clear stranded
+                 * the outer pair's null) */
+                e->q_value_pending = e->qmd_n > 0;
             }
             e->pos++;
             e->cv_line = e->line; /* the value parses on THIS line's colon */

metadata

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