yeptris 0.6.15.2 → 0.6.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1326388a6f59887d9b8f541ec6f4c835071ca05f4821d429a82b8acc1a990e2
-  data.tar.gz: 521f5abbcebb9611a0c67699b1952e72d3790d228fe606148f095d622f5b4387
+  metadata.gz: 36b4d1444bde48fba47b0fd89851f5ebe8cd7a666c7e3faa8652caf4bb37a60f
+  data.tar.gz: 7f113394e8f82d502425610637641716af695a835ba01f6ce5e611c5073c6d55
 SHA512:
-  metadata.gz: 7b6e36f35a32d480af8635023bbaf173194e8295e34851ae53ec8121cdf872e9d71c4877f70cc94d1ee62d0d22e4f74e868edc7746b2fbbd9d66af47f31daad0
-  data.tar.gz: 21a442ef4c99c57f46b837af822db3d98434c476b5a0b7c56d52f03bbfac0c8849be28b2a7fd2109a95b15a80ea6eda9116c3631ff5c6faff2d134e5b2a861fc
+  metadata.gz: cec260d2c0b2c10d152336d0809eca8d9d15c4fc8e52ddac94fa01b8850c3f59cebb74f0ddd78b48f751ce9fb6a1f74e6f9646d81a237144645810949c93b7a0
+  data.tar.gz: efa7dbc2609e25b0d25bb0d93c7d877223808d88343299e7dfd60ed9442eb31806347a4aa1f255452bfc219af2a5d4c34b66f5d50346d839de59ee256dafe0da

data/ext/yeptris_native/cbor_ruby.c

@@ -17,6 +17,14 @@
 #include <stdlib.h>
 #include <string.h>
 
+static rb_encoding* cr_utf8_enc;
+
+/* Map keys repeat across records in CBOR corpora; interning shares one
+ * VALUE per distinct key (the json_ruby.c on_key pattern, #157). */
+static VALUE cr_key_str(const char* p, size_t len) {
+    return rb_enc_interned_str(p, (long)len, cr_utf8_enc);
+}
+
 #include "dom/dom.h"
 #include "doc.h" /* the public YeptrisDocument wrapper: ->dom */
 #include <yeptris/cbor.h>
@@ -91,8 +99,17 @@ static VALUE cr_walk(const yep_dom* d, uint32_t id) {
         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 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;
@@ -107,6 +124,9 @@ static VALUE cr_walk(const yep_dom* d, uint32_t id) {
 }
 
 VALUE yep_rb_cbor_load(const char* p, size_t len, int strict) {
+    if (cr_utf8_enc == NULL) {
+        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

data/lib/yeptris/document.rb

@@ -8,6 +8,11 @@ class Yeptris::Document
   # explicit free path and the finalizer both flip the same flag.
   Freed = Struct.new(:state) # :alive | :freed
 
+  # The raw C handle — the Yeptris::Node wrappers cache by its
+  # address; stream-children wrappers (Document.without_finalizer)
+  # carry it without registering a finalizer (#182).
+  attr_reader :c_ptr
+
   # The schema this document was parsed with (a parse property).
   attr_reader :parse_schema
 
@@ -80,6 +85,18 @@ class Yeptris::Document
     new(c_ptr, Freed.new(:alive), schema)
   end
 
+  # #182: the stream-children wrapper owns NOTHING (the parent
+  # Document wrapper is the sole freer of the C memory). A plain
+  # Document.new would register a finalizer on a c_ptr we don't own;
+  # a parse_stream on a multi-doc stream would free the same pointer
+  # three times at GC → SIGABRT. This factory builds the wrapper
+  # WITHOUT a finalizer; the wrapper's lifetime follows the owner.
+  def self.without_finalizer(c_ptr)
+    doc = new(c_ptr)
+    ObjectSpace.undefine_finalizer(doc)
+    doc
+  end
+
   def ensure_alive!
     raise Yeptris::FreedError, "document is freed" if @freed.state == :freed
   end

data/lib/yeptris/psych.rb

@@ -291,7 +291,15 @@ module Yeptris
         raise SyntaxError.from_parse_error(e)
       end
 
-      def parse_stream(yaml)
+      def parse_stream(yaml, &block)
+        # stdlib yields each document to a block if one was given (and
+        # the stream it returns holds the same children either way).
+        # #182: the wrapper is the sole owner of the C memory — the
+        # stream merely REFERENCES it; the wrapper's own finalizer
+        # 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?
 
@@ -308,6 +316,8 @@ module Yeptris
       rescue Yeptris::ParseError => e
         raise SyntaxError.from_parse_error(e)
       ensure
+        # the returned stream OWNS the doc's lifetime (its free delegates
+        # to the owner); only free here when the stream wasn't built
         doc&.free if doc && !stream
       end
 
@@ -522,8 +532,12 @@ module Yeptris
         # stream owns the yeptris document)
         def document_stream_child(doc, index)
           root = doc.root(index)
-          d = Document.new
-          d.handle = root&.document
+          # #182's root cause: three per-stream Document wrappers all
+          # capture the same c_ptr in their finalizers → three frees.
+          # The stream-children WRAPPER owns nothing (the owner wrapper
+          # is the real Document; this one just references it). Build
+          # a non-owning wrapper with no finalizer.
+          d = Document.send(:new, root&.document, false)
           d.children << node(root) if root
           d
         end

data/lib/yeptris/schema.rb

@@ -66,6 +66,92 @@ module Yeptris
       end
     end
 
+    # #184 (lutaml-model KV path): zip Schema columns into record
+    # hashes ready for Serializable.instantiate. Mapping root → one
+    # hash; sequence-of-mappings → one hash per element; nested
+    # mappings → nested hashes. Returns Array<Hash> always. when_attribute
+    # / polymorphic stay out of scope (interpretive fallback).
+    def load_records(source, schema: :core_12, desc:, capacity: 64)
+      cols = load(source, schema: schema, desc: desc, capacity: capacity)
+      zip_records(desc, cols)
+    end
+
+    def zip_records(desc, cols)
+      root = desc[0] || {}
+      case root[:kind]
+      when :sequence
+        child_start = root[:child_index] || 1
+        child_count = root[:child_count] || 0
+        return [] if child_count.zero?
+
+        child = desc[child_start]
+        if child && child[:kind] == :mapping
+          field_start = child[:child_index] || (child_start + 1)
+          field_count = child[:child_count] || 0
+          fields = desc[field_start, field_count] || []
+          field_cols = cols[field_start, field_count] || []
+          nrows = field_cols.map(&:length).max || 0
+          Array.new(nrows) do |r|
+            h = {}
+            fields.each_with_index do |f, i|
+              next unless f[:wire_name]
+              col = field_cols[i] || []
+              # ABSENT keys are OMITTED, not nil-filled (lutaml-model's
+              # load-bearing edge: absent seeds defaults +
+              # using_default?; explicit nil is a present value with
+              # different render semantics). The C columns fill in
+              # document order — col.length > r means present.
+              next if col.length <= r
+
+              h[f[:wire_name].to_sym] = materialize_field(f, desc, cols, col[r])
+            end
+            h
+          end
+        else
+          (cols[child_start] || []).map { |v| { value: v } }
+        end
+      when :mapping
+        field_start = root[:child_index] || 1
+        field_count = root[:child_count] || 0
+        fields = desc[field_start, field_count] || []
+        field_cols = cols[field_start, field_count] || []
+        h = {}
+        fields.each_with_index do |f, i|
+          next unless f[:wire_name]
+          col = field_cols[i] || []
+          next if col.empty? # absent: omitted, not nil-filled (#184)
+
+          h[f[:wire_name].to_sym] = materialize_field(f, desc, cols, col[0])
+        end
+        [h]
+      else
+        [{ value: cols[0]&.first }]
+      end
+    end
+    private_class_method :zip_records
+
+    def materialize_field(field, desc, cols, cell)
+      case field[:kind]
+      when :mapping
+        start = field[:child_index] || 0
+        count = field[:child_count] || 0
+        return nil if count.zero? || cell.nil?
+
+        nested = {}
+        desc[start, count]&.each_with_index do |nf, i|
+          next unless nf[:wire_name]
+          ncol = cols[start + i] || []
+          nested[nf[:wire_name].to_sym] = ncol.is_a?(Array) ? (ncol[0] rescue cell) : cell
+        end
+        nested
+      when :sequence
+        cell.is_a?(Array) ? cell : Array(cell)
+      else
+        cell
+      end
+    end
+    private_class_method :materialize_field
+
     def compile(desc)
       desc.map do |n|
         { kind: KIND.fetch(n.fetch(:kind)),

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

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

@@ -134,8 +134,17 @@ static void wr_indent(yep_writer* w, int depth) {
 
 static void emit_dq(yep_writer* w, const char* p, uint32_t n) {
     wr_byte(w, '"');
+    uint32_t run = 0;
     for (uint32_t i = 0; i < n; i++) {
         unsigned char c = (unsigned char)p[i];
+        if (c >= 0x20 && c != '"' && c != '\\' && c != 0x7f) {
+            run++;
+            continue;
+        }
+        if (run) {
+            wr_put(w, p + i - run, run);
+            run = 0;
+        }
         if (c == '"' || c == '\\') {
             wr_byte(w, '\\');
             wr_byte(w, (char)c);
@@ -161,10 +170,11 @@ static void emit_dq(yep_writer* w, const char* p, uint32_t n) {
                 char hex[4] = {'\\', 'x', hd[(c >> 4) & 0xf], hd[c & 0xf]};
                 wr_put(w, hex, 4);
             }
-        } else {
-            wr_byte(w, (char)c);
         }
     }
+    if (run) {
+        wr_put(w, p + n - run, run);
+    }
     wr_byte(w, '"');
 }
 
@@ -315,6 +325,10 @@ enum { YEP_SC_NOTHING = 0, YEP_SC_PLAIN, YEP_SC_SQ, YEP_SC_DQ, YEP_SC_LITERAL };
 
 static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key, uint8_t sty_in,
                         int has_tag) {
+    if ((sty_in == 1) && len > 0 &&
+        (as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len))) {
+        return YEP_SC_PLAIN; /* plain-safe implies no breaks: memchr skipped */
+    }
     int multiline = (len > 0 && memchr(p, '\n', len) != NULL);
     int blockable = 0;
     if (multiline && !as_key) {

metadata

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