yeptris 0.6.16.2 → 0.6.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6b3f2406ea8b763cfa7bd0d0a36ea30ba7bb80c8322c6ebe5fd8300725e47d2
-  data.tar.gz: 9a500939ce7f65be9219acc0a44c62819ddd09f4f64486177065681b8490e686
+  metadata.gz: e317e3324f6bd24065dec096878270922234973be2957c7c850fdb59dea214c6
+  data.tar.gz: e98c83679d4228d3b35ee70b527f3d10f916308090f35b17585aaa9679292726
 SHA512:
-  metadata.gz: 6c4eeced42673cb9613462d239f6427bdb1190e14b0a733976e3bd9c17ee061a4fe7fb5f14ace52ea05242b186410570b8d44f1fc5bbc2ab2aacbcd65188d7ef
-  data.tar.gz: 5b84d8229ff419ab0c04fba154088775776ed5f70f4e6be5a9939e9b495e61ac82656a1bf0d7cbddbdf55ae9c1ba1912c44fc2af5b22e16d40a432e71009b185
+  metadata.gz: 4861baa93673811f488bdb34f33826dd9a204eabda55f8b0a2064a2eee1e021e36c49bba8ee597d0ac832c5368bcf572d42adfee257325f46e334ad4e3e7d846
+  data.tar.gz: '08cd8dc7729a1a3eaac787d85e6fdea0bb9001e1bd449e2c31dc57ebc9c2d327ab505f62d6dc647f99dad1d356a3fab3efc6ac3e1c5429e70589581e5114d741'

data/ext/yeptris_native/cbor_ruby.c

@@ -25,102 +25,144 @@ static VALUE cr_key_str(const char* p, size_t len) {
     return rb_enc_interned_str(p, (long)len, cr_utf8_enc);
 }
 
+#include "cbor/sink.h"
 #include "dom/dom.h"
 #include "doc.h" /* the public YeptrisDocument wrapper: ->dom */
 #include <yeptris/cbor.h>
 #include <yeptris/dom.h>
 #include <yeptris/resolve.h>
 
-static const char* cr_view(const yep_dom* d, yep_sview sv, uint32_t* len) {
-    *len = sv.len;
-    if (sv.len == 0) {
-        return "";
-    }
-    return (sv.off & YEP_SV_INPUT) ? (d->str + (sv.off & YEP_SV_OFF)) : (d->input_base + sv.off);
+/* ---- the VALUE sink (#157): bytes -> VALUE in ONE pass ----
+ *
+ * The decode grammar drives; these callbacks build the same VALUEs
+ * the old DOM + cr_walk pair produced (verified by the binding's
+ * differential suite): nil/true/false by tag, ints via LL2NUM (the
+ * INT64_MIN text parity wart kept), floats via DBL2NUM (no
+ * text round trip), strings copied utf8 (byte strings today ride the
+ * same utf8 String), map keys interned (values never are).
+ *
+ * GC: the container stack is a Ruby array (every VALUE reachable);
+ * the input buffer is read directly, so decode runs with GC disabled
+ * (the caller's String may move otherwise — the #160 bus error). */
+
+struct rv_ctx {
+    VALUE stack; /* [.., container, (pending-key)?] */
+    VALUE root;  /* Qnil until the top item closes */
+};
+
+static VALUE rv_top(const struct rv_ctx* c) {
+    long n = RARRAY_LEN(c->stack);
+    return n > 0 ? rb_ary_entry(c->stack, n - 1) : Qnil;
 }
 
-static VALUE cr_scalar(const yep_dom* d, const yep_dnode* n) {
-    uint32_t len = 0;
-    const char* p = cr_view(d, n->value, &len);
-    switch (n->tag_id) {
-    case YEPTRIS_TAG_NULL:
-        return Qnil;
-    case YEPTRIS_TAG_BOOL:
-        if (len == 1) { /* Psych: "y"/"n" stay Strings */
-            return rb_utf8_str_new(p, len);
-        }
-        return (len == 4 && memcmp(p, "true", 4) == 0) ? Qtrue : Qfalse;
-    case YEPTRIS_TAG_INT: {
-        char buf[32];
-        size_t cp = len < sizeof(buf) - 1 ? len : sizeof(buf) - 1;
-        memcpy(buf, p, cp);
-        buf[cp] = '\0';
-        char* end = NULL;
-        long long v = strtoll(buf, &end, 10);
-        if (end != buf && *end == '\0' && end == buf + len && v > INT64_MIN) {
-            return LL2NUM(v);
-        }
-        return rb_utf8_str_new(p, len); /* int_or_string's fallback */
+static VALUE rv_attach(struct rv_ctx* c, VALUE v) {
+    VALUE top = rv_top(c);
+    if (RB_TYPE_P(top, T_ARRAY)) {
+        rb_ary_push(top, v);
+        return v;
     }
-    case YEPTRIS_TAG_FLOAT: {
-        char buf[64];
-        size_t cp = len < sizeof(buf) - 1 ? len : sizeof(buf) - 1;
-        memcpy(buf, p, cp);
-        buf[cp] = '\0';
-        char* end = NULL;
-        double v = strtod(buf, &end);
-        if (end != buf && end != buf + len) {
-            return rb_utf8_str_new(p, len); /* float_or_string's fallback */
-        }
-        return DBL2NUM(v);
+    if (RB_TYPE_P(top, T_HASH)) {
+        rb_ary_push(c->stack, v); /* becomes the pending key */
+        return v;
     }
-    default:
-        return rb_utf8_str_new(p, len);
+    /* a pending key: pop it, land v in the map */
+    VALUE k = rb_ary_pop(c->stack);
+    VALUE map = rv_top(c);
+    if (RB_TYPE_P(map, T_HASH)) {
+        rb_hash_aset(map, k, v);
+        return v;
     }
+    /* the stack emptied: v is the root */
+    c->root = v;
+    return v;
 }
 
-static VALUE cr_walk(const yep_dom* d, uint32_t id) {
-    const yep_dnode* n = &d->nodes[id];
-    switch (n->kind) {
-    case YEP_DOM_SCALAR:
-        return cr_scalar(d, n);
-    case YEP_DOM_SEQUENCE: {
-        long cnt = (long)n->count;
-        VALUE a = rb_ary_new_capa(cnt);
-        uint32_t c = n->first_child;
-        for (long i = 0; i < cnt && c != UINT32_MAX; i++) {
-            rb_ary_push(a, cr_walk(d, c));
-            c = d->nodes[c].next_sibling;
-        }
-        return a;
+static int rv_text(void* ctx, const char* s, uint32_t n, uint8_t tag_id, int is_key,
+                   const char* tag, uint32_t tag_len) {
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v;
+    switch (tag_id) {
+    case YEPTRIS_TAG_NULL:
+        v = Qnil;
+        break;
+    case YEPTRIS_TAG_BOOL:
+        v = (n == 4 && memcmp(s, "true", 4) == 0) ? Qtrue : Qfalse;
+        break;
+    default: /* rendered text (diagnostics, simple(N), key ints) */
+        v = rb_utf8_str_new(s, (long)n);
+        break;
     }
-    case YEP_DOM_MAPPING: {
-        long pairs = (long)(n->count / 2);
-        VALUE h = HASH_NEW_CAPA(pairs);
-        uint32_t c = n->first_child;
-        for (long i = 0; i < pairs && c != UINT32_MAX; i++) {
-            VALUE k;
-            const yep_dnode* kn = &d->nodes[c];
-            if (kn->kind == YEP_DOM_SCALAR && kn->tag_id == YEPTRIS_TAG_STR) {
-                uint32_t klen = 0;
-                const char* kp = cr_view(d, kn->value, &klen);
-                k = cr_key_str(kp, klen);
-                c = kn->next_sibling;
-            } else {
-                k = cr_walk(d, c);
-                c = d->nodes[c].next_sibling;
-            }
-            VALUE v = (c != UINT32_MAX) ? cr_walk(d, c) : Qnil;
-            if (c != UINT32_MAX) {
-                c = d->nodes[c].next_sibling;
-            }
-            rb_hash_aset(h, k, v);
-        }
-        return h;
+    (void)is_key;
+    rv_attach(c, v);
+    return 1;
+}
+
+static int rv_int(void* ctx, int negative, uint64_t mag, int is_key, const char* tag,
+                  uint32_t tag_len) {
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v;
+    if (negative && mag == (uint64_t)1 << 63) {
+        /* parity: the DOM path's strtoll guard renders INT64_MIN a
+         * String today; the differential suite pins it */
+        v = rb_utf8_str_new("-9223372036854775808", 20);
+    } else {
+        v = LL2NUM(negative ? -(int64_t)mag : (int64_t)mag);
     }
-    default: /* ALIAS: CBOR decode never produces one */
-        return Qnil;
+    rv_attach(c, v);
+    return 1;
+}
+
+static int rv_float(void* ctx, double dv, int is_key, const char* tag, uint32_t tag_len) {
+    (void)is_key;
+    (void)tag;
+    (void)tag_len;
+    rv_attach(ctx, DBL2NUM(dv));
+    return 1;
+}
+
+static int rv_str(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                  const char* tag, uint32_t tag_len) {
+    (void)borrowed;
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v = is_key ? rb_enc_interned_str((const char*)p, (long)n, cr_utf8_enc)
+                     : rb_utf8_str_new((const char*)p, (long)n);
+    rv_attach(c, v);
+    return 1;
+}
+
+static int rv_bytes(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                    const char* tag, uint32_t tag_len) {
+    /* parity: byte strings ride the same utf8 String today */
+    return rv_str(ctx, p, n, borrowed, is_key, tag, tag_len);
+}
+
+static int rv_open(void* ctx, int is_map, uint64_t cap, const char* tag, uint32_t tag_len) {
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v;
+    if (is_map) {
+        v = (cap != UINT64_MAX && cap / 2 <= 4096) ? HASH_NEW_CAPA((long)(cap / 2))
+                                                   : rb_hash_new();
+    } else {
+        v = (cap != UINT64_MAX && cap <= 8192) ? rb_ary_new_capa((long)cap) : rb_ary_new();
     }
+    rb_ary_push(c->stack, v);
+    return 1;
+}
+
+static int rv_close(void* ctx, int is_map) {
+    (void)is_map;
+    struct rv_ctx* c = ctx;
+    VALUE v = rb_ary_pop(c->stack);
+    rv_attach(c, v);
+    return 1;
 }
 
 VALUE yep_rb_cbor_load(const char* p, size_t len, int strict) {
@@ -128,27 +170,24 @@ VALUE yep_rb_cbor_load(const char* p, size_t len, int strict) {
         cr_utf8_enc = rb_utf8_encoding();
     }
     YeptrisStatus st = YEPTRIS_OK;
-    /* the DOM borrows the input buffer zero-copy; the walk ALLOCATES,
-     * and a GC compaction mid-walk moves the caller's String — the
-     * borrowed base dangles (the #160 CI bus error on 3.2/linux).
-     * Same discipline as the JSON walk: GC off across decode+walk */
+    /* the decoder reads the caller's buffer directly; GC off across
+     * the pass (a compaction would move the String under p — the
+     * #160 bus error) */
     VALUE gc_on = rb_gc_disable();
-    /* YeptrisDocument is a WRAPPER (doc.h) — ->dom is the tree; a raw
-     * yep_dom* cast read the wrapper's fields as the dom (the CI
-     * segfaults: docs at the wrong offset) */
-    yeptris_document* doc = (yeptris_document*)yeptris_cbor_decode(
-        p, len, strict ? YEPTRIS_CBOR_STRICT : 0, &st);
-    yep_dom* d = (doc != NULL) ? doc->dom : NULL;
-    if (d == NULL) {
-        if (RTEST(gc_on)) {
-            rb_gc_enable();
-        }
-        return Qundef;
-    }
-    VALUE v = (d->dcount > 0 && d->docs[0] != UINT32_MAX) ? cr_walk(d, d->docs[0]) : Qnil;
-    yeptris_document_free((YeptrisDocument)doc);
+    struct rv_ctx ctx;
+    ctx.stack = rb_ary_new();
+    ctx.root = Qnil;
+    static const yep_cbor_sink RV_SINK = {
+        NULL, rv_text, rv_int, rv_float, rv_str, rv_bytes, rv_open, rv_close,
+    };
+    yep_cbor_sink sink = RV_SINK;
+    sink.ctx = &ctx;
+    st = yep_cbor_decode_gen((const unsigned char*)p, len, strict, NULL, &sink);
     if (RTEST(gc_on)) {
         rb_gc_enable();
     }
-    return v;
+    if (st != YEPTRIS_OK) {
+        return Qundef;
+    }
+    return ctx.root;
 }

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.16.2
+  version: 0.6.17.1
 platform: ruby
 authors:
 - Ribose Inc.