very_fast_yaml 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b1692e3ff72ddcb470bd2aacf948130320973863685317ada5eabccbcb4811d7
+  data.tar.gz: 2a763988384b4f273190a0f03b882b00fe649922c5011605fa74edfdf1074808
+SHA512:
+  metadata.gz: 2b643c0974004ca486564625088956cb69909c3d2ddbf144e169250df7fe20d00efde85eb73c1e5e8fd0a271100dbb62693e5a30a47b52d1929eb12e41c0d473
+  data.tar.gz: 659f5f80f09ae9ce5fca24304e4cb6ab048c43dae589a9fdb6a2cfeb981d0c9d253061f662f7aacc6ca8a299a73b2955c07c5813d76d4965d3608ae6d43a624e

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peter Arato
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/ext/rapid_yaml/block.h

@@ -0,0 +1,207 @@
+/* Conservative ASCII block-YAML recognizer. Any uncertainty restarts in libyaml.
+ * Not a separate YAML dialect: acceptance is deliberately narrower than YAML.
+ * Source slices refer to the native copy, never movable Ruby string storage. */
+#include "scan.h"
+
+typedef struct {
+    const unsigned char *s, *end;
+    size_t indent;
+} block_line;
+typedef struct {
+    load_ctx *load;
+    const unsigned char *next, *end;
+    block_line line;
+    int failed;
+} block_ctx;
+
+static int indicator(block_line l, unsigned char ch) {
+    return l.s < l.end && l.s[0] == ch && (l.s + 1 == l.end || l.s[1] == ' ');
+}
+
+static void next_line(block_ctx *b) {
+    while (b->next < b->end) {
+        if ((++b->load->operations & 4095) == 0) rb_thread_check_ints();
+        const unsigned char *start = b->next;
+        const unsigned char *end = memchr(start, '\n', (size_t)(b->end - start));
+        if (!end) end = b->end;
+        b->next = end < b->end ? end + 1 : end;
+        const unsigned char *s = start;
+        while (s < end && *s == ' ') s++;
+        while (end > s && end[-1] == ' ') end--;
+        if (s == end) continue;
+        b->line = (block_line){s, end, (size_t)(s - start)};
+        return;
+    }
+    b->line = (block_line){b->end, b->end, 0};
+}
+
+static void after_indicator(block_ctx *b) {
+    const unsigned char *start = b->line.s;
+    b->line.s++;
+    while (b->line.s < b->line.end && *b->line.s == ' ') b->line.s++;
+    b->line.indent += (size_t)(b->line.s - start);
+}
+
+/* Locate a block map delimiter; quotes are accepted only without escaping. */
+static const unsigned char *map_colon(block_line l) {
+    const unsigned char *p = l.s;
+    if (p < l.end && (*p == '\'' || *p == '"')) {
+        unsigned char quote = *p++;
+        while (p < l.end && *p != quote) { if (*p == '\\') return NULL; p++; }
+        if (p == l.end) return NULL;
+        p++;
+        while (p < l.end && *p == ' ') p++;
+        return p < l.end && *p == ':' && (p + 1 == l.end || p[1] == ' ') ? p : NULL;
+    }
+    for (; p < l.end; p++)
+        if (*p == ':' && (p + 1 == l.end || p[1] == ' ')) return p;
+    return NULL;
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+#define RY_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define RY_UNLIKELY(x) (x)
+#endif
+static const unsigned char reserved_initial[128] = {
+    [','] = 1, ['!'] = 1, ['&'] = 1, ['*'] = 1, ['#'] = 1,
+    ['|'] = 1, ['>'] = 1, ['@'] = 1, ['"'] = 1, [39] = 1,
+    ['%'] = 1, [96] = 1, ['['] = 1, [']'] = 1, ['{'] = 1, ['}'] = 1
+};
+
+static VALUE block_inline(block_ctx *b, const unsigned char *s, const unsigned char *end) {
+    while (end > s && end[-1] == ' ') end--;
+    size_t n = (size_t)(end - s);
+    if (!n) return Qnil;
+    if (n == 2 && s[0] == '[' && s[1] == ']') return rb_ary_new();
+    if (n == 2 && s[0] == '{' && s[1] == '}') return rb_hash_new();
+    if (RY_UNLIKELY(s[0] == '\'' || s[0] == '"')) {
+        unsigned char quote = s[0];
+        if (n < 2 || end[-1] != quote) { b->failed = 1; return Qnil; }
+        for (const unsigned char *p = s + 1; p < end - 1; p++)
+            if (*p == quote || (quote == '"' && *p == '\\')) { b->failed = 1; return Qnil; }
+        return yaml_string(b->load, s + 1, n - 2);
+    }
+    /* Fail closed for properties, directives, comments, block/flow scalars,
+     * document boundaries, and reserved indicators. */
+    if (reserved_initial[s[0]] ||
+        ((s[0] == '-' || s[0] == '?' || s[0] == ':') && (n == 1 || s[1] == ' ')) ||
+        (n >= 3 && (!memcmp(s, "---", 3) || !memcmp(s, "...", 3)))) {
+        b->failed = 1; return Qnil;
+    }
+    for (const unsigned char *p = s; p < end; p++) {
+        if ((*p == '#' && p > s && p[-1] == ' ') ||
+            (*p == ':' && (p + 1 == end || p[1] == ' '))) { b->failed = 1; return Qnil; }
+    }
+    return scalar(b->load, s, n, 1);
+}
+
+static int generic_mapping_tag(const unsigned char *s, size_t n) {
+    if (n < 2 || s[0] != '!' || s[1] == '!' || s[1] == '<') return 0;
+    /* Reserved Ruby and shorthand tags are always delegated. */
+    if ((n >= 6 && !memcmp(s, "!ruby/", 6)) || (n >= 5 && !memcmp(s, "!map:", 5)) || (n >= 4 && !memcmp(s, "!str", 4)) ||
+        (n == 4 && !memcmp(s, "!set", 4)) || (n == 5 && !memcmp(s, "!omap", 5))) return 0;
+    for (size_t i = 1; i < n; i++) {
+        unsigned char ch = s[i];
+        if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
+              (ch >= '0' && ch <= '9') || ch == '_' || ch == ':' || ch == '-' || ch == '/' || ch == '.')) return 0;
+    }
+    return 1;
+}
+
+static VALUE block_node(block_ctx *b);
+
+static VALUE block_value(block_ctx *b, const unsigned char *s, size_t parent_indent) {
+    while (s < b->line.end && *s == ' ') s++;
+    if (s < b->line.end) {
+        if (generic_mapping_tag(s, (size_t)(b->line.end - s))) {
+            next_line(b);
+            if (b->line.s == b->line.end || b->line.indent <= parent_indent) { b->failed = 1; return Qnil; }
+            VALUE result = block_node(b);
+            if (!RB_TYPE_P(result, T_HASH)) b->failed = 1;
+            return result;
+        }
+        VALUE value = block_inline(b, s, b->line.end);
+        next_line(b);
+        return value;
+    }
+    next_line(b);
+    if (b->line.s < b->line.end && (b->line.indent > parent_indent ||
+        (b->line.indent == parent_indent && indicator(b->line, '-')))) return block_node(b);
+    return Qnil;
+}
+
+static VALUE block_node(block_ctx *b) {
+    load_ctx *c = b->load;
+    if (b->failed || c->depth >= 128) { b->failed = 1; return Qnil; }
+    block_line first = b->line;
+    if (first.s == first.end) return Qnil;
+    int sequence = indicator(first, '-');
+    if (!sequence && !indicator(first, '?') && !map_colon(first)) {
+        VALUE value = block_inline(b, first.s, first.end);
+        next_line(b);
+        return value;
+    }
+    VALUE container = sequence ? rb_ary_new() : rb_hash_new();
+    rb_ary_push(c->stack, container);
+    rb_ary_push(c->stack, Qnil);
+    c->wants_value[c->depth++] = 0;
+    while (!b->failed && b->line.s < b->line.end && b->line.indent == first.indent) {
+        if (b->line.indent == 0 && b->line.end - b->line.s == 3 && !memcmp(b->line.s, "...", 3)) break;
+        if (sequence) {
+            if (!indicator(b->line, '-')) break;
+            after_indicator(b);
+            VALUE value;
+            if (b->line.s < b->line.end) {
+                if (generic_mapping_tag(b->line.s, (size_t)(b->line.end - b->line.s)))
+                    value = block_value(b, b->line.s, first.indent);
+                else
+                    value = block_node(b);
+            } else {
+                next_line(b);
+                value = b->line.s < b->line.end && b->line.indent > first.indent ? block_node(b) : Qnil;
+            }
+            rb_ary_push(container, value);
+        } else {
+            VALUE key, value;
+            if (indicator(b->line, '?')) {
+                after_indicator(b);
+                if (b->line.s < b->line.end) key = block_node(b);
+                else {
+                    next_line(b);
+                    key = b->line.s < b->line.end && b->line.indent > first.indent ? block_node(b) : Qnil;
+                }
+                if (b->failed || b->line.indent != first.indent || !indicator(b->line, ':')) { b->failed = 1; break; }
+                if (!attach(c, key)) { b->failed = 1; break; }
+                value = block_value(b, b->line.s + 1, first.indent);
+            } else {
+                const unsigned char *colon = map_colon(b->line);
+                if (!colon || colon == b->line.s) { b->failed = 1; break; }
+                /* YAML limits implicit keys to 1024 Unicode characters. */
+                if ((size_t)(colon - b->line.s) > 1024) { b->failed = 1; break; }
+                key = block_inline(b, b->line.s, colon);
+                if (b->failed || !attach(c, key)) { b->failed = 1; break; }
+                value = block_value(b, colon + 1, first.indent);
+            }
+            if (b->failed || !attach(c, value)) { b->failed = 1; break; }
+        }
+    }
+    c->depth--;
+    rb_ary_pop(c->stack);
+    rb_ary_pop(c->stack);
+    RB_GC_GUARD(container);
+    return container;
+}
+
+static VALUE block_load(load_ctx *c, size_t length) {
+    const unsigned char *end = c->input + length;
+    if (!block_ascii(c->input, end)) return unsupported;
+    block_ctx b = {c, c->input, end, {NULL, NULL, 0}, 0};
+    next_line(&b);
+    if (b.line.indent == 0 && b.line.end - b.line.s == 3 && !memcmp(b.line.s, "---", 3)) next_line(&b);
+    if (b.line.s == b.line.end) return unsupported;
+    VALUE result = block_node(&b);
+    if (!b.failed && b.line.indent == 0 && b.line.end - b.line.s == 3 && !memcmp(b.line.s, "...", 3)) next_line(&b);
+    if (b.failed || b.line.s != b.line.end) return unsupported;
+    return result;
+}

data/ext/rapid_yaml/extconf.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require "mkmf"
+if with_config("yaml-dir") || with_config("yaml-include") || with_config("yaml-lib")
+  dir_config("yaml")
+elsif !pkg_config("yaml-0.1")
+  prefix = ["/opt/homebrew/opt/libyaml", "/usr/local/opt/libyaml"].find { |p| File.file?("#{p}/include/yaml.h") }
+  dir_config("yaml", "#{prefix}/include", "#{prefix}/lib") if prefix
+end
+yaml_available = have_header("yaml.h") &&
+  (have_func("yaml_parser_initialize", "yaml.h") || have_library("yaml", "yaml_parser_initialize"))
+abort "libyaml headers required (brew install libyaml / apt install libyaml-dev)" unless yaml_available
+$CFLAGS << " -O3" unless $CFLAGS.match?(/(?:^|\s)-O(?:[0-3sgz]|fast)(?:\s|$)/)
+$CFLAGS << " -std=c99 -Wall -Wextra -Wno-unused-parameter"
+$defs << "-DRY_DISABLE_SIMD" unless enable_config("simd", true)
+create_makefile("rapid_yaml/rapid_yaml")

data/ext/rapid_yaml/rapid_yaml.c

@@ -0,0 +1,225 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <yaml.h>
+#include <string.h>
+
+#define MAX_DEPTH 512
+static VALUE unsupported;
+static ID id_tokenize;
+static rb_encoding *utf8;
+
+typedef struct {
+    yaml_parser_t parser;
+    yaml_event_t event;
+    int initialized, live_event, depth, mode;
+    size_t length;
+    unsigned int operations;
+    unsigned char wants_value[MAX_DEPTH];
+    unsigned char *input;
+    VALUE stack, scanner, result, key_cache;
+} load_ctx;
+
+static int attach(load_ctx *c, VALUE value) {
+    if (!c->depth) { c->result = value; return 1; }
+    int d = c->depth - 1;
+    VALUE parent = rb_ary_entry(c->stack, d * 2);
+    if (RB_TYPE_P(parent, T_ARRAY)) {
+        rb_ary_push(parent, value);
+    } else if (!c->wants_value[d]) {
+        if (RB_TYPE_P(value, T_STRING) && RSTRING_LEN(value) == 2 && !memcmp(RSTRING_PTR(value), "<<", 2)) return 0;
+        rb_ary_store(c->stack, d * 2 + 1, value);
+        c->wants_value[d] = 1;
+    } else {
+        rb_hash_aset(parent, rb_ary_entry(c->stack, d * 2 + 1), value);
+        /* The next key overwrites this slot; no write barrier is needed to clear it. */
+        c->wants_value[d] = 0;
+    }
+    return 1;
+}
+
+static int ascii_equal_ci(const unsigned char *s, const char *word, size_t n) {
+    for (size_t i = 0; i < n; i++) if ((s[i] | 32) != (unsigned char)word[i]) return 0;
+    return 1;
+}
+
+static VALUE yaml_string(load_ctx *c, const unsigned char *s, size_t n) {
+    if (c->depth && !c->wants_value[c->depth - 1] && RB_TYPE_P(rb_ary_entry(c->stack, (c->depth - 1) * 2), T_HASH)) {
+        if (n && n <= 64) {
+            unsigned int slot = (s[0] * 3 + s[n - 1] * 17 + n * 7) & 127;
+            VALUE key = rb_ary_entry(c->key_cache, slot);
+            if (!NIL_P(key) && (size_t)RSTRING_LEN(key) == n && !memcmp(RSTRING_PTR(key), s, n)) return key;
+            key = rb_enc_interned_str((const char *)s, (long)n, utf8);
+            rb_ary_store(c->key_cache, slot, key);
+            return key;
+        }
+        return rb_enc_interned_str((const char *)s, (long)n, utf8);
+    }
+    return rb_utf8_str_new((const char *)s, (long)n);
+}
+
+/* Reject impossible numeric candidates before invoking Psych's regex scanner.
+ * This is a superset recognizer, not an alternative scalar schema: timestamps,
+ * radix numbers, symbols and all ambiguous candidates still use Psych. */
+static int possibly_typed(const unsigned char *s, size_t n) {
+    size_t start = (n && (s[0] == '-' || s[0] == '+')) ? 1 : 0;
+    if (!n || s[0] == ':' || start == n) return 1;
+    if (n > start + 4 && s[start + 4] == '-') return 1;
+    if (n > start + 1 && s[start] == '0' && (s[start + 1] == 'x' || s[start + 1] == 'b')) return 1;
+    if (s[start] == '.' && n - start == 4) return 1;
+    unsigned int dots = 0, colons = 0, exponents = 0;
+    for (size_t i = start; i < n; i++) {
+        unsigned char ch = s[i];
+        if ((ch >= '0' && ch <= '9') || ch == ',' || ch == '_') continue;
+        if (ch == '.' && ++dots == 1) continue;
+        if (ch == ':' && ++colons <= 2) continue;
+        if ((ch == 'e' || ch == 'E') && ++exponents == 1) continue;
+        if ((ch == '-' || ch == '+') && i > start && (s[i-1] == 'e' || s[i-1] == 'E')) continue;
+        return 0;
+    }
+    return 1;
+}
+
+/* Plain shortcuts require single-line ASCII; callers must establish this. */
+static VALUE scalar(load_ctx *c, const unsigned char *s, size_t n, int plain) {
+    if (plain) {
+        if (!n || (n == 1 && s[0] == '~')) return Qnil;
+        unsigned char first = s[0] | 32;
+        if ((first >= 'a' && first <= 'z') || s[0] == '_') {
+            if ((n == 4 && ascii_equal_ci(s, "null", 4))) return Qnil;
+            if ((n == 4 && ascii_equal_ci(s, "true", 4)) || (n == 3 && ascii_equal_ci(s, "yes", 3)) || (n == 2 && ascii_equal_ci(s, "on", 2))) return Qtrue;
+            if ((n == 5 && ascii_equal_ci(s, "false", 5)) || (n == 2 && ascii_equal_ci(s, "no", 2)) || (n == 3 && ascii_equal_ci(s, "off", 3))) return Qfalse;
+            return yaml_string(c, s, n);
+        }
+        size_t i = (s[0] == '-' || s[0] == '+') ? 1 : 0;
+        if (i < n && n - i <= 18 && (s[i] != '0' || n - i == 1)) {
+            unsigned long long number = 0;
+            for (; i < n && s[i] >= '0' && s[i] <= '9'; i++) number = number * 10 + s[i] - '0';
+            if (i == n) return s[0] == '-' ? LL2NUM(-(long long)number) : ULL2NUM(number);
+        }
+    }
+    VALUE string = yaml_string(c, s, n);
+    return plain && possibly_typed(s, n) ? rb_funcall(c->scanner, id_tokenize, 1, string) : string;
+}
+
+#include "block.h"
+
+static VALUE event_scalar(load_ctx *c, yaml_event_t *e) {
+    const unsigned char *s = e->data.scalar.value;
+    size_t n = e->data.scalar.length;
+    int plain = e->data.scalar.style == YAML_PLAIN_SCALAR_STYLE;
+    if (plain) {
+        /* Psych uses Unicode case folding and line-anchored scalar regexes.
+         * Preserve their long-s/ligature and multiline behavior. The block
+         * tier already proves single-line ASCII; this tier must check. */
+        for (size_t i = 0; i < n; i++) {
+            if (s[i] >= 128 || s[i] == '\n' || s[i] == '\r')
+                return rb_funcall(c->scanner, id_tokenize, 1, yaml_string(c, s, n));
+        }
+    }
+    return scalar(c, s, n, plain);
+}
+
+static VALUE load_body(VALUE arg) {
+    load_ctx *c = (load_ctx *)arg;
+    if (c->mode != 1) {
+        VALUE fast = block_load(c, c->length);
+        if (fast != unsupported || c->mode == 2) return fast;
+        rb_ary_clear(c->stack);
+        c->depth = 0;
+    }
+    if (!yaml_parser_initialize(&c->parser)) rb_memerror();
+    c->initialized = 1;
+    /* Psych treats UTF-8/ASCII/binary Strings as UTF-8, unlike binary IO. */
+    yaml_parser_set_encoding(&c->parser, YAML_UTF8_ENCODING);
+    yaml_parser_set_input_string(&c->parser, c->input, c->length);
+    for (;;) {
+        if ((++c->operations & 4095) == 0) rb_thread_check_ints();
+        if (!yaml_parser_parse(&c->parser, &c->event)) return unsupported;
+        c->live_event = 1;
+        yaml_event_t *e = &c->event;
+        VALUE value;
+        switch (e->type) {
+          case YAML_STREAM_START_EVENT: case YAML_DOCUMENT_START_EVENT: break;
+          case YAML_STREAM_END_EVENT: return unsupported; /* empty stream: use Psych's fallback */
+          case YAML_DOCUMENT_END_EVENT: return c->result;
+          case YAML_ALIAS_EVENT: return unsupported;
+          case YAML_SCALAR_EVENT:
+            if (e->data.scalar.anchor || e->data.scalar.tag) return unsupported;
+            value = event_scalar(c, e);
+            if (!attach(c, value)) return unsupported;
+            break;
+          case YAML_SEQUENCE_START_EVENT: case YAML_MAPPING_START_EVENT:
+            if (c->depth == MAX_DEPTH) return unsupported;
+            if (e->type == YAML_SEQUENCE_START_EVENT) {
+                if (e->data.sequence_start.anchor || e->data.sequence_start.tag) return unsupported;
+                value = rb_ary_new();
+            } else {
+                if (e->data.mapping_start.anchor) return unsupported;
+                const char *tag = (const char *)e->data.mapping_start.tag;
+                /* Psych treats unregistered, non-special mapping tags as hashes.
+                 * !str is a special Ruby string shorthand, not a generic tag. */
+                if (tag && (strstr(tag, "ruby/") || !strncmp(tag, "!map:", 5) || !strncmp(tag, "!str", 4) ||
+                            !strncmp(tag, "!set", 4) || !strncmp(tag, "!omap", 5) ||
+                            !strncmp(tag, "tag:yaml.org,2002:", 18))) return unsupported;
+                value = rb_hash_new();
+            }
+            rb_ary_push(c->stack, value);
+            rb_ary_push(c->stack, Qnil);
+            c->wants_value[c->depth++] = 0;
+            break;
+          case YAML_SEQUENCE_END_EVENT: case YAML_MAPPING_END_EVENT:
+            c->depth--;
+            rb_ary_pop(c->stack);
+            value = rb_ary_pop(c->stack);
+            if (!attach(c, value)) return unsupported;
+            break;
+          default: return unsupported;
+        }
+        yaml_event_delete(&c->event);
+        c->live_event = 0;
+    }
+}
+
+static VALUE load_cleanup(VALUE arg) {
+    load_ctx *c = (load_ctx *)arg;
+    if (c->live_event) yaml_event_delete(&c->event);
+    if (c->initialized) yaml_parser_delete(&c->parser);
+    xfree(c->input);
+    return Qnil;
+}
+
+static VALUE native_load_impl(VALUE source, VALUE scanner, int mode) {
+    Check_Type(source, T_STRING);
+    load_ctx c = {0};
+    c.stack = rb_ary_new();
+    c.key_cache = rb_ary_new_capa(128);
+    c.scanner = scanner;
+    c.result = Qnil;
+    size_t length = (size_t)RSTRING_LEN(source);
+    c.length = length;
+    c.mode = mode;
+    c.input = ALLOC_N(unsigned char, length ? length : 1);
+    memcpy(c.input, RSTRING_PTR(source), length);
+    VALUE result = rb_ensure(load_body, (VALUE)&c, load_cleanup, (VALUE)&c);
+    RB_GC_GUARD(c.stack);
+    RB_GC_GUARD(c.key_cache);
+    RB_GC_GUARD(c.scanner);
+    RB_GC_GUARD(c.result);
+    return result;
+}
+
+static VALUE native_load(VALUE self, VALUE source, VALUE scanner) { return native_load_impl(source, scanner, 0); }
+static VALUE native_events_load(VALUE self, VALUE source, VALUE scanner) { return native_load_impl(source, scanner, 1); }
+static VALUE native_block_load(VALUE self, VALUE source, VALUE scanner) { return native_load_impl(source, scanner, 2); }
+
+void Init_rapid_yaml(void) {
+    VALUE mod = rb_define_module("RapidYAML");
+    unsupported = rb_obj_freeze(rb_obj_alloc(rb_cObject));
+    rb_define_const(mod, "UNSUPPORTED", unsupported);
+    rb_global_variable(&unsupported);
+    id_tokenize = rb_intern("tokenize");
+    utf8 = rb_utf8_encoding();
+    rb_define_singleton_method(mod, "native_load", native_load, 2);
+    rb_define_singleton_method(mod, "native_events_load", native_events_load, 2);
+    rb_define_singleton_method(mod, "native_block_load", native_block_load, 2);
+}

data/ext/rapid_yaml/scan.h

@@ -0,0 +1,29 @@
+/* Bounded unaligned vector loads; no padding, aliasing, or endian assumptions.
+ * Advanced SIMD is baseline on AArch64, SSE2 on x86-64. Other CPUs use C. */
+#if !defined(RY_DISABLE_SIMD) && defined(__aarch64__)
+#include <arm_neon.h>
+#elif !defined(RY_DISABLE_SIMD) && defined(__SSE2__)
+#include <emmintrin.h>
+#endif
+
+static int block_ascii(const unsigned char *p, const unsigned char *end) {
+#if !defined(RY_DISABLE_SIMD) && defined(__aarch64__)
+    while (end - p >= 16) {
+        uint8x16_t v = vld1q_u8(p);
+        uint8x16_t valid = vorrq_u8(vceqq_u8(v, vdupq_n_u8(10)),
+            vandq_u8(vcgeq_u8(v, vdupq_n_u8(32)), vcleq_u8(v, vdupq_n_u8(126))));
+        if (vminvq_u8(valid) != 255) return 0;
+        p += 16;
+    }
+#elif !defined(RY_DISABLE_SIMD) && defined(__SSE2__)
+    while (end - p >= 16) {
+        __m128i v = _mm_loadu_si128((const __m128i *)p);
+        __m128i valid = _mm_or_si128(_mm_cmpeq_epi8(v, _mm_set1_epi8(10)),
+            _mm_andnot_si128(_mm_cmpgt_epi8(v, _mm_set1_epi8(126)), _mm_cmpgt_epi8(v, _mm_set1_epi8(31))));
+        if (_mm_movemask_epi8(valid) != 65535) return 0;
+        p += 16;
+    }
+#endif
+    for (; p < end; p++) if ((*p < 32 && *p != 10) || *p > 126) return 0;
+    return 1;
+}

data/lib/rapid_yaml/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module RapidYAML
+  VERSION = "0.1.3"
+end

data/lib/rapid_yaml/yaml.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+require "rapid_yaml"
+RapidYAML.install!

data/lib/rapid_yaml.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+require "yaml"
+require "forwardable"
+require_relative "rapid_yaml/version"
+require "rapid_yaml/rapid_yaml"
+
+# Requiring rapid_yaml does not patch Psych. See rapid_yaml/yaml for opt-in.
+module RapidYAML
+  PSYCH_METHODS = Psych.singleton_methods(false).to_h { |name| [name, Psych.method(name)] }.freeze
+  FAST_ENCODINGS = [Encoding::UTF_8, Encoding::US_ASCII, Encoding::ASCII_8BIT].freeze
+  NATIVE_LOADER = ENV["RAPID_YAML_ENGINE"] == "events" ? :native_events_load : :native_load
+  ACCELERATED_METHODS = %i[load safe_load unsafe_load load_file safe_load_file unsafe_load_file].freeze
+  MAX_FILE_BYTES = 16 * 1024 * 1024
+  LOAD_KEYWORDS = %i[aliases filename fallback].freeze
+  UNSAFE_KEYWORDS = %i[filename fallback].freeze
+  private_constant :PSYCH_METHODS, :FAST_ENCODINGS, :NATIVE_LOADER, :ACCELERATED_METHODS, :MAX_FILE_BYTES, :LOAD_KEYWORDS, :UNSAFE_KEYWORDS
+
+  # Real method definitions, rather than captured Proc bodies, can run in Ractors.
+  extend SingleForwardable
+  def_single_delegators "::Psych", *(PSYCH_METHODS.keys - ACCELERATED_METHODS)
+
+  def self.secondary_ractor?
+    defined?(Ractor) && Ractor.current != Ractor.main
+  end
+
+  def self.load(source, **options)
+    return Psych.load(source, **options) if secondary_ractor?
+    accelerated_load(:load, source, options)
+  end
+
+  def self.safe_load(source, **options)
+    return Psych.safe_load(source, **options) if secondary_ractor?
+    accelerated_load(:safe_load, source, options)
+  end
+
+  def self.unsafe_load(source, **options)
+    return Psych.unsafe_load(source, **options) if secondary_ractor?
+    accelerated_load(:unsafe_load, source, options)
+  end
+
+  def self.load_file(filename, **options)
+    return Psych.load_file(filename, **options) if secondary_ractor?
+    accelerated_file(:load, filename, options)
+  end
+
+  def self.safe_load_file(filename, **options)
+    return Psych.safe_load_file(filename, **options) if secondary_ractor?
+    accelerated_file(:safe_load, filename, options)
+  end
+
+  def self.unsafe_load_file(filename, **options)
+    return Psych.unsafe_load_file(filename, **options) if secondary_ractor?
+    accelerated_file(:unsafe_load, filename, options)
+  end
+
+  def self.accelerated_load(name, source, options)
+    original = PSYCH_METHODS.fetch(name)
+    fast_keywords = name == :unsafe_load ? UNSAFE_KEYWORDS : LOAD_KEYWORDS
+    tags = Psych.load_tags
+    unless source.instance_of?(String) && FAST_ENCODINGS.include?(source.encoding) &&
+        (options.keys - fast_keywords).empty? &&
+        (options[:filename].nil? || options[:filename].instance_of?(String)) &&
+        tags.empty? && tags.default.nil? && tags.default_proc.nil? && Psych.domain_types.empty?
+      return original.call(source, **options)
+    end
+    loader = name == :unsafe_load ? Psych::ClassLoader.new : Psych::ClassLoader::Restricted.new(name == :load ? ["Symbol"] : [], [])
+    begin
+      value = public_send(NATIVE_LOADER, source, Psych::ScalarScanner.new(loader))
+    rescue StandardError
+      # Psych parses before resolving scalars: retain its error precedence.
+      return original.call(source, **options)
+    end
+    value.equal?(UNSUPPORTED) ? original.call(source, **options) : value
+  end
+  private_class_method :accelerated_load
+
+  def self.accelerated_file(name, filename, options)
+    File.open(filename, "r:bom|utf-8") do |file|
+      stat = file.stat
+      source = if stat.file? && stat.size.positive? && stat.size <= MAX_FILE_BYTES && Encoding.default_internal.nil?
+        # Bound reads of changing files; preserve the BOM-selected encoding.
+        (file.read(stat.size) || "").force_encoding(file.external_encoding)
+      else
+        # Preserve incremental IO and transcoding for devices and large files.
+        file
+      end
+      public_send(name, source, filename: filename, **options)
+    end
+  end
+  private_class_method :accelerated_file
+
+  def self.const_missing(name)
+    Psych.const_get(name)
+  end
+
+  # Explicit, process-wide and idempotent; call during application boot.
+  def self.install!
+    Psych.singleton_class.prepend(YAMLAcceleration) unless Psych.singleton_class < YAMLAcceleration
+    self
+  end
+
+  module YAMLAcceleration
+    # Do not enter Proc-backed methods or read captured Method objects outside
+    # the main Ractor. `super` retains Psych's own Ractor-local configuration.
+    def load(...)
+      return super if RapidYAML.secondary_ractor?
+      RapidYAML.load(...)
+    end
+
+    def safe_load(...)
+      return super if RapidYAML.secondary_ractor?
+      RapidYAML.safe_load(...)
+    end
+
+    def unsafe_load(...)
+      return super if RapidYAML.secondary_ractor?
+      RapidYAML.unsafe_load(...)
+    end
+
+    def load_file(...)
+      return super if RapidYAML.secondary_ractor?
+      RapidYAML.load_file(...)
+    end
+
+    def safe_load_file(...)
+      return super if RapidYAML.secondary_ractor?
+      RapidYAML.safe_load_file(...)
+    end
+
+    def unsafe_load_file(...)
+      return super if RapidYAML.secondary_ractor?
+      RapidYAML.unsafe_load_file(...)
+    end
+  end
+  private_constant :YAMLAcceleration
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: very_fast_yaml
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Peter Arato
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: forwardable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+executables: []
+extensions:
+- ext/rapid_yaml/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- ext/rapid_yaml/block.h
+- ext/rapid_yaml/extconf.rb
+- ext/rapid_yaml/rapid_yaml.c
+- ext/rapid_yaml/scan.h
+- lib/rapid_yaml.rb
+- lib/rapid_yaml/version.rb
+- lib/rapid_yaml/yaml.rb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Native YAML loading with a Psych-compatible Ruby interface
+test_files: []