yeptris 0.6.16.1-aarch64-linux → 0.6.17.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2612a8d5390e6bf215a646fee2c582ff4aaa1091a65d26fb0f113220983741c
-  data.tar.gz: c706b95796ded1c06c4ea4a41415ee484c6f894d9fdbf8652f20d3f3adae5c9b
+  metadata.gz: 64ddefe5a0f3a289ff538849a99d7214d8068898a50d01f5c14cac178885d7c2
+  data.tar.gz: cd9384a1b05f3c04f390a322b5a7f7e4b8cb5f17224bbd45a2ee04fbf00f6ded
 SHA512:
-  metadata.gz: 0ad96188aa09042b35024144cdb9b555abfc0bf5731d73f4d246b4d84cbd2b001080f769d3fa8a0f1488b3ce41da672881724fb21acb431a74ddbb43a468664f
-  data.tar.gz: 496b1c54f30d326cf2999fca95105c56756bf4addb32b32e4d46651a2930921973bda3c8bf488e23b7c63185be3223210cc1deeb2e2e9a1fc2dfd39e5163c185
+  metadata.gz: 78c6aa4ea3a6b1b802af4cf106f92dad2cdd168cb70506c48c971eae37511148a9600b379a8cd340966e3bd83224654fadbf7629ff820da6e661d61e277d0ffb
+  data.tar.gz: 8c6e9f8989af0f628fc352107c35571edd75c79284c6795cd26b81cc53732a364b9b6d55d3d6ae703cd5af9dbe0ceddb76ca0c6f05f6405c715a9ee01cab99f5

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/ext/yeptris_native/yeptris_native.c

@@ -423,8 +423,51 @@ static VALUE native_gc_mode_set(VALUE self, VALUE mode) {
     return mode;
 }
 
+/* ABI-drift self-check (the #157-audit silent-nil class): the bundle
+ * is compiled against a specific yep_dom layout; engine drift makes
+ * the walkers read fields at stale offsets — cbor_load returned NIL
+ * on valid CBOR in the dev-checkout audit, with no error anywhere.
+ * Both walkers must round-trip a known document at load, or Init
+ * raises LoadError: lib/yeptris.rb's existing rescue falls back to
+ * the FFI ladder (loudly), and the stale bundle never answers with
+ * garbage. Runs inside rb_protect so a drifted walk raises instead of
+ * crashing the load. */
+static VALUE native_self_check_body(VALUE unused) {
+    /* JSON: {"a"=>[1, 2.5, "x", true, nil]} */
+    const char* json = "{\"a\":[1,2.5,\"x\",true,null]}";
+    VALUE j = yep_rb_parse_json(json, strlen(json), 0);
+    if (j == Qundef || !RB_TYPE_P(j, T_HASH)) return Qfalse;
+    VALUE a = rb_hash_lookup(j, rb_str_new_cstr("a"));
+    if (!RB_TYPE_P(a, T_ARRAY) || RARRAY_LEN(a) != 5) return Qfalse;
+    if (!RB_INTEGER_TYPE_P(rb_ary_entry(a, 0))) return Qfalse;
+    if (!RB_FLOAT_TYPE_P(rb_ary_entry(a, 1))) return Qfalse;
+    if (!RB_TYPE_P(rb_ary_entry(a, 2), T_STRING)) return Qfalse;
+    if (rb_ary_entry(a, 3) != Qtrue || !NIL_P(rb_ary_entry(a, 4))) return Qfalse;
+
+    /* CBOR: A1 61 6B 01 = {"k" => 1} (canonical, hand-encoded) */
+    const char cbor[] = "\xA1\x61\x6B\x01";
+    VALUE c = yep_rb_cbor_load(cbor, sizeof(cbor) - 1, 0);
+    if (c == Qundef || !RB_TYPE_P(c, T_HASH)) return Qfalse;
+    VALUE one = rb_hash_lookup(c, rb_str_new_cstr("k"));
+    if (!RB_INTEGER_TYPE_P(one) || !rb_eql(one, INT2FIX(1))) return Qfalse;
+    return Qtrue;
+}
+
+static void native_self_check(void) {
+    int state = 0;
+    VALUE ok = rb_protect(native_self_check_body, Qnil, &state);
+    if (state != 0 || ok != Qtrue) {
+        if (state != 0) rb_set_errinfo(Qnil);
+        rb_raise(rb_eLoadError,
+                 "yeptris: native materializer failed its ABI self-check "
+                 "(stale build against a drifted engine?) — refusing to "
+                 "register; the FFI ladder will carry the load");
+    }
+}
+
 RUBY_FUNC_EXPORTED void Init_native(void) {
     utf8_enc = rb_utf8_encoding();
+    native_self_check();
     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);

data/lib/yeptris/json.rb

@@ -119,7 +119,7 @@ module Yeptris
       end
     end
 
-    def walk_tape(src, tape)
+    def walk_tape(src, tape, strict_dup = STRICT_DUPLICATE_KEYS)
       n = tape[:count]
       kinds = tape[:kinds].read_bytes(n).unpack("C*")
       offs = tape[:offs].read_bytes(n * 4).unpack("V*")
@@ -139,7 +139,7 @@ module Yeptris
 
       docs = [nil] # record 0 (DOC) pre-consumed — the root's slot
       stack = []
-      key_sets = STRICT_DUPLICATE_KEYS ? [{}] : nil
+      key_sets = strict_dup ? [{}] : nil
       pending_key = nil
       i = 1
       while i < n
@@ -152,8 +152,12 @@ module Yeptris
           place(docs, stack, pending_key) { {} }
           pending_key = nil
         when T_CLOSE
+          # Key frames are pushed per MAP_OPEN — an ARRAY close must
+          # not pop the enclosing map's frame (issue found by ea's CI:
+          # {"a":[1],"b":[2],"c":[3]} exhausted the frames and the next
+          # map key hit key_sets.last.key? on nil under strict mode).
+          key_sets&.pop if stack.last.is_a?(Hash)
           stack.pop
-          key_sets&.pop
         when T_STR
           # empty-string literals are frozen+shared since Ruby 3.4
           # (and `+""` binds after the method chain anyway), so the
@@ -256,8 +260,8 @@ module Yeptris
           place(docs, stack, pending_key) { {} }
           pending_key = nil
         when ValueML::CLOSE
+          key_sets&.pop if stack.last.is_a?(Hash)
           stack.pop
-          key_sets&.pop
         when ValueML::V_STR
           text = arena.byteslice(offs[i], lens[i])
           if ikeys[i] == 1 && !stack.empty? && stack.last.is_a?(Hash)

data/lib/yeptris/psych/class_loader.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Yeptris
+  module Psych
+    # The minimal ClassLoader face the ScalarScanner port drives
+    # (stdlib's loader resolves through the class hierarchy; the
+    # scanner only needs the date class and symbolize).
+    class ClassLoader
+      def date
+        Date
+      end
+
+      def symbolize str
+        str.to_sym
+      end
+
+      def load name
+        Object.const_get(name)
+      end
+    end
+  end
+end

data/lib/yeptris/psych/scalar_scanner.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Yeptris
+  module Psych
+    ###
+    # Scan scalars for built in types — the stdlib Psych::ScalarScanner
+    # port (#179): same regexes, same precedence, same edge verdicts.
+    # The load path types through the C resolver; this class is the
+    # standalone API stdlib code (and Psych's own tests) drive directly.
+    class ScalarScanner
+      # Taken from http://yaml.org/type/timestamp.html
+      TIME = /^-?\d{4}-\d{1,2}-\d{1,2}(?:[Tt]|\s+)\d{1,2}:\d\d:\d\d(?:\.\d*)?(?:\s*(?:Z|[-+]\d{1,2}:?(?:\d\d)?))?$/
+
+      # Taken from http://yaml.org/type/float.html
+      # Base 60, [-+]inf and NaN are handled separately
+      FLOAT = /^(?:[-+]?([0-9][0-9_,]*)?\.[0-9]*([eE][-+][0-9]+)?(?# base 10))$/x
+
+      # Taken from http://yaml.org/type/int.html and modified to ensure at least one numerical symbol exists
+      INTEGER_STRICT = /^(?:[-+]?0b[_]*[0-1][0-1_]*             (?# base 2)
+                           |[-+]?0[_]*[0-7][0-7_]*              (?# base 8)
+                           |[-+]?(0|[1-9][0-9_]*)               (?# base 10)
+                           |[-+]?0x[_]*[0-9a-fA-F][0-9a-fA-F_]* (?# base 16))$/x
+
+      # Same as above, but allows commas.
+      # Not to YML spec, but kept for backwards compatibility
+      INTEGER_LEGACY = /^(?:[-+]?0b[_,]*[0-1][0-1_,]*                (?# base 2)
+                           |[-+]?0[_,]*[0-7][0-7_,]*                 (?# base 8)
+                           |[-+]?(?:0|[1-9](?:[0-9]|,[0-9]|_[0-9])*) (?# base 10)
+                           |[-+]?0x[_,]*[0-9a-fA-F][0-9a-fA-F_,]*    (?# base 16))$/x
+
+      BOOLEAN_TRUE  = /^(yes|true|on)$/i
+      BOOLEAN_FALSE = /^(no|false|off)$/i
+
+      attr_reader :class_loader
+
+      # Create a new scanner
+      def initialize class_loader = ClassLoader, strict_integer: false, parse_symbols: true
+        @symbol_cache = {}
+        @class_loader = class_loader
+        @strict_integer = strict_integer
+        @parse_symbols = parse_symbols
+      end
+
+      # Tokenize +string+ returning the Ruby object
+      def tokenize string
+        return nil if string.empty?
+        return @symbol_cache[string] if @symbol_cache.key?(string)
+        integer_regex = @strict_integer ? INTEGER_STRICT : INTEGER_LEGACY
+        # Check for a String type, being careful not to get caught by hash keys, hex values, and
+        # special floats (e.g., -.inf).
+        if string.match?(%r{^[^\d.:-]?[[:alpha:]_\s!@#$%\^&*(){}<>|/\\~;=]+}) || string.match?(/\n/)
+          return string if string.length > 5
+
+          if string.match?(/^[^ytonf~]/i)
+            string
+          elsif string == '~' || string.match?(/^null$/i)
+            nil
+          elsif string.match?(BOOLEAN_TRUE)
+            true
+          elsif string.match?(BOOLEAN_FALSE)
+            false
+          else
+            string
+          end
+        elsif string.match?(TIME)
+          begin
+            parse_time string
+          rescue ArgumentError
+            string
+          end
+        elsif string.match?(/^\d{4}-(?:1[012]|0\d|\d)-(?:[12]\d|3[01]|0\d|\d)$/)
+          begin
+            class_loader.date.strptime(string, '%F', Date::GREGORIAN)
+          rescue ArgumentError
+            string
+          end
+        elsif string.match?(/^\+?\.inf$/i)
+          Float::INFINITY
+        elsif string.match?(/^-\.inf$/i)
+          -Float::INFINITY
+        elsif string.match?(/^\.nan$/i)
+          Float::NAN
+        elsif @parse_symbols && string.match?(/^:./)
+          if string =~ /^:(["'])(.*)\1/
+            @symbol_cache[string] = class_loader.symbolize($2.sub(/^:/, ''))
+          else
+            @symbol_cache[string] = class_loader.symbolize(string.sub(/^:/, ''))
+          end
+        elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}$/)
+          i = 0
+          string.split(':').each_with_index do |n, e|
+            i += (n.to_i * 60**(e - 2).abs)
+          end
+          i
+        elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}\.[0-9_]*$/)
+          i = 0
+          string.split(':').each_with_index do |n, e|
+            i += (n.to_f * 60**(e - 2).abs)
+          end
+          i
+        elsif string.match?(FLOAT)
+          if string.match?(/\A[-+]?\.\Z/)
+            string
+          else
+            Float(string.delete(',_').gsub(/\.([Ee]|$)/, '\1'))
+          end
+        elsif string.match?(integer_regex)
+          parse_int string
+        else
+          string
+        end
+      end
+
+      # Parse and return an int from +string+
+      def parse_int string
+        Integer(string.delete(',_'))
+      end
+
+      ###
+      # Parse and return a Time from +string+
+      def parse_time string
+        date, time = *(string.split(/[Tt]|\s+/, 2))
+        (yy, m, dd) = date.match(/^(-?\d{4})-(\d{1,2})-(\d{1,2})/).captures.map { |x| x.to_i }
+        md = time.match(/(\d+:\d+:\d+)(?:\.(\d*))?\s*(Z|[-+]\d+(:\d\d)?)?/)
+
+        (hh, mm, ss) = md[1].split(':').map { |x| x.to_i }
+        us = (md[2] ? Rational("0.#{md[2]}") : 0) * 1_000_000
+
+        time = Time.utc(yy, m, dd, hh, mm, ss, us)
+
+        return time if 'Z' == md[3]
+        return Time.at(time.to_i, us) unless md[3]
+
+        tz = md[3].match(/^([+\-]?\d{1,2})\:?(\d{1,2})?$/)[1..-1].compact.map { |digit| Integer(digit, 10) }
+        offset = tz.first * 3600
+
+        if offset < 0
+          offset -= ((tz[1] || 0) * 60)
+        else
+          offset += ((tz[1] || 0) * 60)
+        end
+
+        Time.new(yy, m, dd, hh, mm, ss + us / 1_000_000r, offset)
+      end
+    end
+  end
+end

data/lib/yeptris/psych.rb

@@ -22,6 +22,9 @@ require "yeptris"
 # document without materializing.
 module Yeptris
   module Psych
+    autoload :ClassLoader, "yeptris/psych/class_loader"
+    autoload :ScalarScanner, "yeptris/psych/scalar_scanner"
+
     # The tag registries (Psych's class-level API, #95 bug 4):
     # load_tags maps a serialized tag to the Class that revives it;
     # dump_tags overrides the emitted tag for a Class. Consulted by
@@ -258,18 +261,28 @@ module Yeptris
         ::Yeptris::Psych.dump(obj, io, options)
       end
 
-      def load_stream(yaml, **kwargs)
+      def load_stream(yaml, **kwargs, &block)
         # materialize each document's root directly — the stream
         # children share one C document, so their handles would all
-        # resolve to the first document's tree
+        # resolve to the first document's tree. stdlib's block form
+        # yields each loaded document's object (#179 round 4).
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
         return nil if doc.nil? # the legal empty stream
 
         begin
-          (0...doc.document_count).map { |i| doc.root(i).to_ruby }
+          docs = (0...doc.document_count).map { |i| doc.root(i).to_ruby }
         ensure
           doc.free
         end
+        docs.each { |d| block.call(d) } if block
+        docs
+      end
+
+      # safe_load_stream: stdlib's surface — the stream form of
+      # safe_load. Our load_stream is already safe-by-default
+      # (Psych 5 semantics), so this is the yielding wrapper.
+      def safe_load_stream(yaml, **kwargs, &block)
+        load_stream(yaml, **kwargs, &block)
       end
 
       # The first document's node tree (no Ruby materialization).
@@ -299,13 +312,14 @@ module Yeptris
         # handles GC-free. (The block-yielding form is tracked under
         # #179: the current implementation materializes eagerly; the
         # block is only honored as a no-op convenience.)
-        _ = block # reserved for the future yielding form (#179)
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
         return nil if doc.nil? || doc.document_count.zero?
 
         stream = Nodes::Stream.new
         (0...doc.document_count).each do |i|
-          stream.children << Nodes::Builder.document_stream_child(doc, i)
+          child = Nodes::Builder.document_stream_child(doc, i)
+          stream.children << child
+          block.call(child) if block # stdlib's yielding form (#179 round 4)
         end
         # ownership: the DOCUMENT wrapper is the sole owner — its own
         # finalizer (pointer-only closure) frees the C memory; the
@@ -450,6 +464,10 @@ module Yeptris
       # tree stay valid while the tree is reachable; a GC finalizer
       # releases the C memory when it is not.
       class Document < Node
+          # The document's root as a Ruby object (the stream-yield face).
+          def to_ruby
+            children.first&.to_ruby
+          end
         attr_reader :version, :tags
 
         def initialize(version = [], tags = {})

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.1".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
 )

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

@@ -65,7 +65,9 @@ enum {
                                     (default: last, as at parse) */
 };
 
-/* One plan node. 32 bytes, ABI-pinned. */
+/* One plan node. ABI-pinned: a pointer plus 16 fixed-width bytes —
+ * 24 on LP64, 20 on 32-bit (the hosts' FFI mirrors size :pointer
+ * per-process, so the layout contract is the POINTER plus the tail). */
 typedef struct yeptris_desc_node {
     const char* wire_name; /* mapping key to match (NULL: the root) */
     uint8_t kind;          /* YEP_SK_* */
@@ -77,7 +79,7 @@ typedef struct yeptris_desc_node {
     uint32_t reserved;     /* must be 0 (ABI headroom) */
 } yeptris_desc_node;
 
-YEPTRIS_CT_ASSERT(sizeof(yeptris_desc_node) == 24);
+YEPTRIS_CT_ASSERT(sizeof(yeptris_desc_node) == sizeof(const char*) + 16);
 
 /* One column's output. Caller allocates the payload array (sized by
  * expectation); the call fills it and sets count. No per-value FFI: