yeptris 0.6.9.1 → 0.6.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e582f07e09108f29273584fd4e7cb2387bc9410fda6d11a2f0209c40211d8a1c
-  data.tar.gz: 717cca7da0595ecd5ed4d356deabeca49343ce9d81cb40d13d5d2056595d0881
+  metadata.gz: 128c08457353396f6f709f8719256a3b3ce1463518456b34987f252314a0dda4
+  data.tar.gz: 9c20441656c1fdb05003d3e0fa0ee4af6d7d758d5505d387fb09dfb86d37e493
 SHA512:
-  metadata.gz: 552e9e7a9a024ebfb948717acbd15d845844159bd9b66fe4b2db29b5ae611e9cc09584aa1b66fc2a38c813532b4ba779c750b0c5e10cb0ecd81fe960afb5e3e8
-  data.tar.gz: f2a9fc0879fae9b0c498203552d48ac7574807eba66187e28e551efaff472f74dc3881fb4a43d552494a59b75f1af2298b6b0b2fa3167d5aabc8d5231a4ef4f8
+  metadata.gz: a3db668d48f7febd05d6ab518c5696704a6673fe5b9e7dd2fab2ea3ea3fcb41e021cb41b3136ddc96f6d5540a8ee9e8cc6c37997ff4a56de719ec1e783fa7fa0
+  data.tar.gz: 4cb9c60fd78802cb49a97fffb1ce9fd27e047cd5204edf5c1e2621110613122babbac634d2a273a360029ea6c5df15bbdb7298fcb100c3fa53a66abb838bbf56

data/ext/yeptris_native/cbor_ruby.c

@@ -0,0 +1,134 @@
+/* cbor_ruby.c — CBOR decode → Ruby VALUE in one C pass (#157).
+ *
+ * The FFI ladder's CBOR.load pays decode + a Marshal emit/load round
+ * trip; this walks the decoded DOM directly, building the same VALUEs
+ * the materializer builds (tag-driven scalar semantics, insertion-
+ * order mappings), with no intermediate representation.
+ */
+#include <ruby.h>
+/* rb_hash_new_capa is Ruby 3.2+; older Rubies grow dynamically (the
+ * json_ruby.c guard, verbatim). */
+#if RUBY_API_VERSION_MAJOR > 3 || (RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 2)
+#define HASH_NEW_CAPA(n) rb_hash_new_capa(n)
+#else
+#define HASH_NEW_CAPA(n) rb_hash_new()
+#endif
+#include <ruby/encoding.h>
+#include <stdlib.h>
+#include <string.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);
+}
+
+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 */
+    }
+    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);
+    }
+    default:
+        return rb_utf8_str_new(p, len);
+    }
+}
+
+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;
+    }
+    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 = 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;
+    }
+    default: /* ALIAS: CBOR decode never produces one */
+        return Qnil;
+    }
+}
+
+VALUE yep_rb_cbor_load(const char* p, size_t len, int strict) {
+    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 */
+    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);
+    if (RTEST(gc_on)) {
+        rb_gc_enable();
+    }
+    return v;
+}

data/ext/yeptris_native/yeptris_native.c

@@ -230,6 +230,7 @@ static const YeptrisVisitVTable k_vt = {
 
 /* fused JSON→Ruby (json_ruby.c) — no vtable, beats JSON.parse */
 VALUE yep_rb_parse_json(const char* p, size_t len, int strict_dup);
+VALUE yep_rb_cbor_load(const char* p, size_t len, int strict);
 
 static VALUE ctx_result(rb_ctx* c, YeptrisStatus st) {
     if (st != YEPTRIS_OK || c->failed) {
@@ -244,6 +245,18 @@ static VALUE ctx_result(rb_ctx* c, YeptrisStatus st) {
     return c->root;
 }
 
+static VALUE native_cbor_load(int argc, VALUE* argv, VALUE self) {
+    (void)self;
+    VALUE input, strict;
+    rb_scan_args(argc, argv, "11", &input, &strict);
+    StringValue(input);
+    VALUE v = yep_rb_cbor_load(RSTRING_PTR(input), (size_t)RSTRING_LEN(input), RTEST(strict));
+    if (v == Qundef) {
+        rb_raise(rb_path2class("Yeptris::ParseError"), "native cbor decode failed");
+    }
+    return v;
+}
+
 static VALUE native_load_json(int argc, VALUE* argv, VALUE self) {
     (void)self;
     VALUE input, strict;
@@ -415,6 +428,7 @@ RUBY_FUNC_EXPORTED void Init_native(void) {
     VALUE mYep = rb_define_module("Yeptris");
     VALUE mNat = rb_define_module_under(mYep, "Native");
     rb_define_singleton_method(mNat, "load_json", native_load_json, -1);
+    rb_define_singleton_method(mNat, "cbor_load", native_cbor_load, -1);
     rb_define_singleton_method(mNat, "load", native_load, 2);
     rb_define_singleton_method(mNat, "load_stream", native_load_stream, 2);
     rb_define_singleton_method(mNat, "gc_mode", native_gc_mode, 0);

data/lib/yeptris/cbor.rb

@@ -26,6 +26,13 @@ module Yeptris
     def load(data, strict: false)
       raise Error, "libyeptris has no CBOR support" unless available?
 
+      # #157: the native materializer (decode + direct VALUE
+      # construction in one C pass) when the extension is loaded;
+      # the FFI ladder otherwise
+      if defined?(::Yeptris::Native) && ::Yeptris::Native.respond_to?(:cbor_load)
+        return ::Yeptris::Native.cbor_load(data, strict)
+      end
+
       doc_ptr = ::Yeptris::FFI.yeptris_cbor_decode(data, data.bytesize, strict ? STRICT : 0, nil)
       raise ParseError, ::Yeptris::FFI.last_error_message if doc_ptr.null?
 

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.9.1".freeze
+  VERSION = "0.6.9.2".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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.9.1
+  version: 0.6.9.2
 platform: ruby
 authors:
 - Ribose Inc.
@@ -37,6 +37,7 @@ files:
 - README.adoc
 - ext/build_windows_native.rb
 - ext/libyeptris/extconf.rb
+- ext/yeptris_native/cbor_ruby.c
 - ext/yeptris_native/extconf.rb
 - ext/yeptris_native/json_ruby.c
 - ext/yeptris_native/yeptris_native.c