yeptris 0.6.34.3-arm-linux-eabihf → 0.6.35.1-arm-linux-eabihf

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8189e4ab2261a07bf9d18bb5df19c095cea91b787d5e09a65eeacb7e1352f20b
-  data.tar.gz: f246d41d0e0c84be06b54aa8d3ba4c2ef63009a017ade6f7fa2f637c723f45fb
+  metadata.gz: 9b7db4e1966499241be6cb407b04fd1d00ebebbb4c3e47990d95b592311bab1f
+  data.tar.gz: 0771a50cd9613aa73b1e7cf26348fc603b3e8fc008d74cc3d05ced5ed339322f
 SHA512:
-  metadata.gz: b0b627fc761ab8bb6d4d33556019f06d6d5451382bc81f55b33d826ab73056c99c03eb4062c1902135a02c0ff0fe1f12495c1bb130e07c10ed7f12b0cf4af151
-  data.tar.gz: 2c9cb261f7bb8ba85f13915a62dfaa97ac31e4f25c94df139026b13d53478cebee0c678bd51048ee8639aceeba5154c6e4cc1214e752f4c97e48a85d35551e92
+  metadata.gz: 57af21b77819242da81fe856358b9e6f334bb4d69fbf1688be872f023c5fa0b5658e857cb01bac592986f84c759504e3780ff2816204b63bff9263f6b8687b09
+  data.tar.gz: a5b5b8cdbfeaff4272413a0ce5c14d3b3d488582e9648e559f10026fbb907f77faecfd8632c7e50bc9e7272945a35e66946723956b099f43a4b44be46021d188

data/lib/yeptris/cbor.rb

@@ -103,8 +103,12 @@ module Yeptris
     def build_documents(objects)
       # ONE document per object: a visitor's tree is a single
       # document and push sets its root — reuse would overwrite
+      # compat_11 types the documents' plain scalars through the
+      # Psych-compatible resolver — the same law the tree builder's
+      # plain-safety check rides, so a host String stays a CBOR text
+      # string ("1e0" resolved as a float through core-12: #293).
       objects.map do |obj|
-        visitor = ::Yeptris::Psych::Visitors::YAMLTree.new
+        visitor = ::Yeptris::Psych::Visitors::YAMLTree.new(schema: :compat_11)
         visitor.push(obj)
         visitor.document
       end

data/lib/yeptris/document.rb

@@ -75,8 +75,16 @@ class Yeptris::Document
   end
 
   # An empty document for from-scratch construction (TODO.impl/11 p3).
-  def self.create
-    doc = Yeptris::FFI.yeptris_document_new
+  # schema: :compat_11 types its plain scalars through the Psych-
+  # compatible resolver — the dump faces build with it so a host String
+  # the tree builder kept plain ("1e0") stays a string (#293).
+  def self.create(schema: nil)
+    doc =
+      if schema == :compat_11
+        Yeptris::FFI.yeptris_document_new_schema(Yeptris::FFI::SCHEMA_11_COMPAT)
+      else
+        Yeptris::FFI.yeptris_document_new
+      end
     raise Yeptris::Error, "yeptris_document_new failed" if doc.null?
 
     wrap(doc)

data/lib/yeptris/ffi.rb

@@ -141,6 +141,7 @@ module Yeptris
 
     # construction (TODO.impl/11 phase 3)
     attach_function :yeptris_document_new, [], :yeptris_document
+    attach_function :yeptris_document_new_schema, [:int], :yeptris_document
     attach_function :yeptris_document_set_root,
                     %i[yeptris_document yeptris_node], :int
     attach_function :yeptris_node_new_mapping, [:yeptris_document], :yeptris_node

data/lib/yeptris/psych/visitors.rb

@@ -18,8 +18,8 @@ module Yeptris
           new
         end
 
-        def initialize
-          @tree = ::Yeptris::Document.create
+        def initialize(schema: nil)
+          @tree = ::Yeptris::Document.create(schema: schema)
           @names = {}  # object_id -> anchor name
           @counter = 0
         end

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

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

@@ -9,6 +9,7 @@
 
 #include <yeptris/api.h>
 #include <yeptris/error.h>
+#include <yeptris/resolve.h> /* YeptrisSchema */
 #include <yeptris/types.h>
 
 #ifdef __cplusplus
@@ -99,6 +100,11 @@ YEPTRIS_API size_t yeptris_node_children(YeptrisNode node, YeptrisNode* out, siz
 /* An empty document with no input; build nodes and set the root. */
 YEPTRIS_API YeptrisDocument yeptris_document_new(void);
 
+/* The same, with the schema resolver plain scalars type through
+ * (YEPTRIS_SCHEMA_12_CORE is yeptris_document_new's default). Additive
+ * ABI. */
+YEPTRIS_API YeptrisDocument yeptris_document_new_schema(YeptrisSchema schema);
+
 /* Records a detached node as document i's root. */
 YEPTRIS_API int yeptris_document_set_root(YeptrisDocument doc, YeptrisNode root);
 

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

@@ -11,6 +11,7 @@
 #include "doc.h"
 #include "dom/dom.h"
 #include "memory/allocator.h"
+#include "resolve/resolver.h"
 
 static yeptris_document* doc_of(YeptrisDocument handle) {
     return (yeptris_document*)handle;
@@ -38,6 +39,21 @@ YEPTRIS_API YeptrisDocument yeptris_document_new(void) {
     return (YeptrisDocument)doc;
 }
 
+/* An empty document whose plain scalars type through the given
+ * schema's resolver (yeptris_document_new rides the core-12 default).
+ * The CBOR/dump faces create compat-11 documents so a host String the
+ * tree builder kept plain ("1e0" — Psych's dot-required float law)
+ * stays a text string instead of resolving as a float (#293's shape). */
+YEPTRIS_API YeptrisDocument yeptris_document_new_schema(YeptrisSchema schema) {
+    YeptrisDocument doc = yeptris_document_new();
+    if (doc != NULL) {
+        yeptris_document* d = (yeptris_document*)doc;
+        d->dom->resolver =
+            schema == YEPTRIS_SCHEMA_11_COMPAT ? yep_resolver_compat11() : yep_resolver_core12();
+    }
+    return doc;
+}
+
 YEPTRIS_API int yeptris_document_set_root(YeptrisDocument handle, YeptrisNode root) {
     yeptris_document* doc = doc_of(handle);
     yeptris_node* n = node_of(root);

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

@@ -630,7 +630,7 @@ void yep_dom_destroy(yep_dom* d) {
 #include "scan/json.h"
 #include "scan/scan.h"
 
-static const yep_resolver* dom_resolver(const yep_dom* d) {
+const yep_resolver* yep_dom_resolver(const yep_dom* d) {
     return d->resolver != NULL ? d->resolver : yep_resolver_core12();
 }
 
@@ -682,7 +682,7 @@ static int jb_scalar_node(jbuilder* b) {
     yep_dnode* n = &b->d->nodes[id];
     size_t start = b->i;
     size_t i = b->i;
-    const yep_resolver* r = dom_resolver(b->d);
+    const yep_resolver* r = yep_dom_resolver(b->d);
     if (b->p[i] == 't') {
         if (!yep_json_literal(b->p, b->len, &i, "true")) {
             return -2;
@@ -846,7 +846,7 @@ int dom_on_flow_build(void* ctx, const char* p, size_t open, size_t len, uint32_
     d->map_pending_key[d->depth] = 0;
     d->stack[d->depth++] = root;
 
-    const yep_resolver* r = dom_resolver(d);
+    const yep_resolver* r = yep_dom_resolver(d);
     yep_json_walk w;
     yep_json_tok t;
     yep_json_walk_init(&w, p, len, open, max_depth);
@@ -1126,7 +1126,7 @@ int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint16_t ke
     if (d->depth >= YEP_DOM_MAX_DEPTH) {
         return 0;
     }
-    const yep_resolver* r = dom_resolver(d);
+    const yep_resolver* r = yep_dom_resolver(d);
     uint32_t mid = dom_open_node(d, YEP_DOM_MAPPING, NULL, NULL, 0, 0, 0, 0);
     if (mid == UINT32_MAX) {
         return -1;
@@ -1151,7 +1151,7 @@ int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint16_t ke
  * opened before offering — node-for-node the event path's item. */
 int dom_on_block_item(void* ctx, const yep_block_value* v) {
     yep_dom* d = (yep_dom*)ctx;
-    const yep_resolver* r = dom_resolver(d);
+    const yep_resolver* r = yep_dom_resolver(d);
     uint32_t vid = dom_open_node(d, YEP_DOM_SCALAR, NULL, NULL, 0, YEP_STYLE_PLAIN, 1, 0);
     if (vid == UINT32_MAX) {
         return -1;
@@ -1178,7 +1178,7 @@ int dom_on_block_pair(void* ctx, const yep_view* key, const yep_block_value* v,
             return 0;
         }
     }
-    const yep_resolver* r = dom_resolver(d);
+    const yep_resolver* r = yep_dom_resolver(d);
     uint32_t kid = dom_open_node(d, YEP_DOM_SCALAR, NULL, NULL, 0, YEP_STYLE_PLAIN, 1, 0);
     if (kid == UINT32_MAX) {
         return -1;

data/vendor/libyeptris/src/yeptris/dom/dom.h

@@ -300,6 +300,11 @@ yep_sview yep_dom_str_put(yep_dom* d, const char* p, uint32_t len);
 char* yep_dom_str_tail(yep_dom* d, uint32_t cap);
 yep_sview yep_dom_str_commit(yep_dom* d, uint32_t written);
 void yep_dom_destroy(yep_dom* d);
+
+/* The document's implicit-typing resolver (its own, or the core-12
+ * default) — the SSOT the mutation and build paths must share. */
+struct yep_resolver;
+const struct yep_resolver* yep_dom_resolver(const yep_dom* d);
 int yep_dom_on_event(void* ctx, const yep_event* ev);
 
 /* Node id accessor for the public API layer. */

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

@@ -54,8 +54,8 @@ uint32_t yep_mut_scalar(yep_dom* d, const char* value, size_t len, uint8_t style
     }
     n->value = yep_dom_str_put(d, v.p ? (const char*)v.p : "", v.len);
     n->style = style;
-    n->tag_id = style == YEP_STYLE_PLAIN ? yep_resolver_core12()->resolve(NULL, v.p, v.len)
-                                         : YEPTRIS_TAG_STR;
+    n->tag_id =
+        style == YEP_STYLE_PLAIN ? yep_dom_resolver(d)->resolve(NULL, v.p, v.len) : YEPTRIS_TAG_STR;
     return id;
 }
 

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

@@ -80,6 +80,14 @@ int yep_style_plain_safe(const char* p, uint32_t len) {
         while (i + 8 <= len) {
             uint64_t w;
             memcpy(&w, p + i, 8);
+            if (w & HIGH) {
+                /* multibyte content: the byte loop owns the rest — a raw
+                 * LS/PS/NEL rides in a scalar value since the quote-aware
+                 * normalizer (#638) and is a line break on re-parse, so
+                 * the value must be quoted, not plain (the nightly's
+                 * round 18, crash-1e79b2e3) */
+                break;
+            }
             uint64_t space = YST_ZDET(w, ' ');
             uint64_t tab = YST_ZDET(w, '\t');
             uint64_t blank = space | tab;
@@ -113,6 +121,13 @@ int yep_style_plain_safe(const char* p, uint32_t len) {
             if (is_break(c) || c == '\t') {
                 return 0;
             }
+            if ((unsigned char)c == 0xE2 && i + 2 < len && (unsigned char)p[i + 1] == 0x80 &&
+                ((unsigned char)p[i + 2] & 0xFE) == 0xA8) {
+                return 0; /* a raw LS/PS re-parses as a line break */
+            }
+            if ((unsigned char)c == 0xC2 && i + 1 < len && (unsigned char)p[i + 1] == 0x85) {
+                return 0; /* a raw NEL ditto */
+            }
             if (c == ':') {
                 if (i + 1 >= len || is_blank(p[i + 1])) {
                     return 0;

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

@@ -847,7 +847,13 @@ static int key_written_over_limit(yep_writer* w, const yep_dnode* kn) {
      * 38200627503") */
     if (q != NULL) {
         for (uint32_t i = 0; i < n; i++) {
-            est += (q[i] < 0x20 || q[i] >= 0x7F || q[i] == '"' || q[i] == '\\') ? 4u : 1u;
+            /* a single-quoted render DOUBLES every apostrophe; without
+             * it the estimate missed a 892-char key carrying 137
+             * quotes (rendered 1031, re-parse rejected the simple
+             * key — the nightly's crash-b8a18e43) */
+            est += (q[i] < 0x20 || q[i] >= 0x7F || q[i] == '"' || q[i] == '\\' || q[i] == '\'')
+                       ? 4u
+                       : 1u;
         }
     }
     if (kn->anchor.len > 0) {

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

@@ -668,9 +668,13 @@ static YeptrisStatus map_fail(int rc) {
  * contract.
  *
  * Key identity is the record's typed payload: span kinds compare the
- * arena bytes, the rest compare (kind, b, payload). One growable
- * open-addressing table serves the INNERMOST open map (cleared on
- * close) — duplicates are per-map by definition.
+ * arena bytes, the rest compare (kind, b, payload). Duplicates are
+ * per-map by definition, so the scan keeps ONE open-addressing table
+ * per open container on a frame stack: a key registers in the
+ * innermost frame and frames pop on CLOSE. A single table cleared on
+ * open cannot express this — a parent key equal to a key in an
+ * earlier child object was a false duplicate, and a parent duplicate
+ * after a nested object went unseen.
  */
 
 typedef struct {
@@ -682,8 +686,13 @@ typedef struct {
 typedef struct {
     dup_slot* slots;
     size_t cap; /* power of two */
+    size_t count;
 } dup_set;
 
+typedef struct {
+    dup_set keys;
+} dup_frame;
+
 static uint64_t dup_hash(const dup_slot* k, const char* arena) {
     uint64_t h = 1469598103934665603ull;
     if (k->len != UINT32_MAX && (k->kind == YEP_V_STR || k->kind == YEP_V_TIMESTAMP ||
@@ -717,61 +726,102 @@ static int dup_eq(const dup_slot* a, const dup_slot* b, const char* arena) {
     return a->len == 0 || memcmp(arena + a->off, arena + b->off, a->len) == 0;
 }
 
-static int dup_set_grow(dup_set* s) {
+static int dup_set_grow(dup_set* s, const char* arena) {
     size_t ncap = s->cap ? s->cap * 2 : 16;
     dup_slot* ns = calloc(ncap, sizeof(*ns));
     if (ns == NULL) {
         return -1;
     }
-    if (s->slots != NULL) {
-        free(s->slots);
+    for (size_t i = 0; i < s->cap; i++) {
+        dup_slot* old = &s->slots[i];
+        if (old->p == 0) {
+            continue;
+        }
+        uint64_t h = dup_hash(old, arena);
+        while (ns[h & (ncap - 1)].p != 0) {
+            h++;
+        }
+        ns[h & (ncap - 1)] = *old;
     }
+    free(s->slots);
     s->slots = ns;
     s->cap = ncap;
     return 0;
 }
 
+/* 1 = duplicate, 0 = inserted, -1 = oom. Load factor stays <= 1/2. */
+static int dup_set_insert(dup_set* s, const dup_slot* k, const char* arena) {
+    if ((s->count + 1) * 2 > s->cap && dup_set_grow(s, arena) != 0) {
+        return -1;
+    }
+    uint64_t h = dup_hash(k, arena);
+    for (;;) {
+        dup_slot* slot = &s->slots[h & (s->cap - 1)];
+        if (slot->p == 0) {
+            *slot = *k;
+            s->count++;
+            return 0;
+        }
+        if (dup_eq(slot, k, arena)) {
+            return 1;
+        }
+        h++;
+    }
+}
+
 /* 1 = duplicate found (TLS error set), 0 = clean, -1 = oom */
 static int strict_dup_scan(const yep_value_ctx* c) {
-    dup_set s = {NULL, 0};
+    dup_frame* frames = NULL;
+    size_t depth = 0, cap = 0;
     int rc = 0;
     const YeptrisValue* vals = c->vals;
     for (size_t i = 0; i < c->n && rc == 0; i++) {
         const YeptrisValue* v = &vals[i];
-        if (v->kind == YEP_V_MAP_OPEN) {
-            if (s.slots != NULL) {
-                memset(s.slots, 0, s.cap * sizeof(*s.slots)); /* innermost map only */
+        if (v->kind == YEP_V_MAP_OPEN || v->kind == YEP_V_SEQ_OPEN) {
+            if (depth == cap) {
+                size_t ncap = cap ? cap * 2 : 16;
+                dup_frame* nf = realloc(frames, ncap * sizeof(*nf));
+                if (nf == NULL) {
+                    rc = -1;
+                    break;
+                }
+                frames = nf;
+                cap = ncap;
             }
+            frames[depth].keys.slots = NULL;
+            frames[depth].keys.cap = 0;
+            frames[depth].keys.count = 0;
+            depth++;
             continue;
         }
-        if (v->kind == YEP_V_CLOSE || v->is_key != 1) {
+        if (v->kind == YEP_V_CLOSE) {
+            if (depth > 0) {
+                depth--;
+                free(frames[depth].keys.slots);
+            }
+            continue;
+        }
+        if (v->is_key != 1 || depth == 0) {
             continue;
         }
         dup_slot k = {v->p, v->off, v->len, v->kind, v->b};
         if (k.p == 0) {
             k.p = 1; /* never aliases the empty-slot sentinel */
         }
-        if (s.cap == 0 && dup_set_grow(&s) != 0) {
-            rc = -1;
-            break;
-        }
-        uint64_t h = dup_hash(&k, c->arena);
-        for (;;) {
-            dup_slot* slot = &s.slots[h & (s.cap - 1)];
-            if (slot->p == 0) {
-                *slot = k;
-                break;
-            }
-            if (dup_eq(slot, &k, c->arena)) {
-                yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
-                              "duplicate key in object");
-                rc = 1;
-                break;
+        int irc = dup_set_insert(&frames[depth - 1].keys, &k, c->arena);
+        if (irc != 1) {
+            if (irc < 0) {
+                rc = -1;
             }
-            h++;
+            continue;
         }
+        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++) {
+        free(frames[j].keys.slots);
     }
-    free(s.slots);
+    free(frames);
     return rc;
 }