yeptris 0.6.35.1-arm-linux-eabihf → 0.6.36.0-arm-linux-eabihf

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b7db4e1966499241be6cb407b04fd1d00ebebbb4c3e47990d95b592311bab1f
-  data.tar.gz: 0771a50cd9613aa73b1e7cf26348fc603b3e8fc008d74cc3d05ced5ed339322f
+  metadata.gz: f66c1643edcda6eba3086c332c967a59ce9b04175d2fb7f98f468cf4326319f4
+  data.tar.gz: 5ecef3fe6e04298e507ffdee8762ab02cc95752f366ca25adea27f3d56246086
 SHA512:
-  metadata.gz: 57af21b77819242da81fe856358b9e6f334bb4d69fbf1688be872f023c5fa0b5658e857cb01bac592986f84c759504e3780ff2816204b63bff9263f6b8687b09
-  data.tar.gz: a5b5b8cdbfeaff4272413a0ce5c14d3b3d488582e9648e559f10026fbb907f77faecfd8632c7e50bc9e7272945a35e66946723956b099f43a4b44be46021d188
+  metadata.gz: e03bca368d020c5358c7f870b792b584982bfde46f20cf1efa37327c8e8c0f19cbbd2047b6fe0aa9f06aca6bfa5984065ab049c21d38438ef09848a35d16a361
+  data.tar.gz: b61301d36a1743bd89c0210468994e4e280b9a1d2b25031f4db96d0c0caa6d10c72694528ef64a596e3b2686538695bf514e5632a778bd2938c51171e671b645

data/lib/yeptris/cbor.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "yeptris"
+require "yeptris/psych" # the encode path builds through the psych YAMLTree
+
 module Yeptris
   # CBOR (RFC 8949) over the same FFI document the rest of the
   # binding rides (TODO.cbor/04). Decode materializes through the

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "yeptris"
+
 module Yeptris
   # The STRICT JSON surface (TODO.restructure/31).
   #
@@ -365,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)
@@ -375,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.1".freeze
+  VERSION = "0.6.36.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.36
     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;
@@ -3628,6 +3642,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 +4129,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 == '>') {
@@ -5450,10 +5500,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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.35.1
+  version: 0.6.36.0
 platform: arm-linux-eabihf
 authors:
 - Ribose Inc.