yeptris 0.6.15.1 → 0.6.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0033737c829c7beb3ae83ca816033386b4fe23b53968f2b0ff40a74c97aac469
-  data.tar.gz: c27accdae4e4807500d4edbfa39228b003c70e5380de3f259bd5315dc9a2dc6f
+  metadata.gz: 36b4d1444bde48fba47b0fd89851f5ebe8cd7a666c7e3faa8652caf4bb37a60f
+  data.tar.gz: 7f113394e8f82d502425610637641716af695a835ba01f6ce5e611c5073c6d55
 SHA512:
-  metadata.gz: ca7d477d959df73f231e443f15ceef0403774129e2df0af49d94e2f926d24c380cbacf6e92d88e9488715c028de0533e93fa82ca039ee129dd13b90f4b4badd0
-  data.tar.gz: 54b35dfe9c5399157ffbbb1e33b058afbe523e36222771d000ff697ccaccd059d5b049a3383ac2fbad61086d4548d3bc23343f600311c4c8438535d2a87cc2a8
+  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
 
@@ -20,7 +25,7 @@ class Yeptris::Document
     # always yields the same Ruby object (identity for aliases/eql?),
     # cleared at free — no stale entries, no GC-race weak maps.
     @wrapper_cache = {}
-    ObjectSpace.define_finalizer(self, self.class.finalize(c_ptr, freed)) unless c_ptr.null?
+    ObjectSpace.define_finalizer(self, self.class.finalize(c_ptr)) unless c_ptr.null?
   end
 
   def self.parse(yaml, schema: :core_12, max_depth: 0)
@@ -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
@@ -88,6 +105,9 @@ class Yeptris::Document
     return if @freed.state == :freed
 
     @freed.state = :freed
+    # stop the GC finalizer BEFORE the C free — it captures the same
+    # pointer, and its firing after this free is the double free
+    ObjectSpace.undefine_finalizer(self)
     @wrapper_cache.clear
     Yeptris::FFI.yeptris_document_free(@c_ptr)
   end
@@ -221,12 +241,15 @@ class Yeptris::Document
     self
   end
 
-  # GC safety net: an explicit #free already ran is fine; a miss here
-  # frees C memory that would otherwise leak.
-  def self.finalize(c_ptr, freed)
-    proc do
-      Yeptris::FFI.yeptris_document_free(c_ptr) if freed.state == :alive
-      freed.state = :freed
-    end
+  # GC safety net (#182): the proc captures ONLY the raw pointer — no
+  # Ruby objects, no wrapper, no freed-flag struct. A finalizer that
+  # closes over the owning wrapper races that wrapper's own sweep
+  # (the classic use-after-free: freed?/free against half-collected
+  # ivars, then a garbage C pointer into yeptris_document_free →
+  # SIGABRT). Explicit #free undefines this finalizer BEFORE the C
+  # free, so the double free cannot happen; finalizers run on the
+  # main thread, so there is no cross-thread window.
+  def self.finalize(c_ptr)
+    proc { Yeptris::FFI.yeptris_document_free(c_ptr) }
   end
 end

data/lib/yeptris/materializer.rb

@@ -115,7 +115,11 @@ module Yeptris
       end
 
       def parse_timestamp(v)
-        return Date.parse(v) unless v.match?(/[Tt ]\d/)
+        # stdlib scalar_scanner: date-only strings parse with
+        # strptime('%F', Date::GREGORIAN) — the PROLEPTIC calendar —
+        # not Date.parse's default ITALY reform (a 1582 cycle fails
+        # the ported test_julian_date otherwise)
+        return ::Date.strptime(v, "%F", ::Date::GREGORIAN) unless v.match?(/[Tt ]\d/)
 
         # normalize the YAML 1.1 space forms onto iso8601 for
         # xmlschema: "2001-12-14 21:59:43.10 -05:00" ->

data/lib/yeptris/node.rb

@@ -394,6 +394,15 @@ class Yeptris::Node
   def scalar_to_ruby
     return symbolize if symbol? && tag_id == :str
 
+    # stdlib deserialize's tagged-scalar arms: the class tag carries
+    # DateTime (dumped tagged — a plain timestamp re-loads as Time)
+    if tag == "!ruby/object:DateTime"
+      ts = value.to_s.sub(/ (\d)/, 'T\\1').sub(/ ([+-]\d)/, '\\1')
+      t = ::Time.xmlschema(ts)
+      return ::DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec,
+                              Rational(t.utc_offset, 86_400)) + Rational(t.subsec, 86_400)
+    end
+
     case tag_id
     when :null then nil
     when :bool then to_bool

data/lib/yeptris/psych/visitors.rb

@@ -66,11 +66,34 @@ module Yeptris
           end
         end
 
+        # stdlib register()s every object — scalars included — so a
+        # repeated scalar dumps &name/*name (test_float_references,
+        # test_alias_with_time). Containers already route through
+        # anchor_for; this is the scalar arm of the same machinery.
+        def anchored_scalar(obj, text: nil, tag: nil)
+          state, name = anchor_for(obj)
+          return alias_of(obj, name) if state == :alias
+
+          n = scalar(text || obj, tag: tag)
+          n.set_anchor(name) if name
+          remember(obj, n)
+          n
+        end
+
         def visit(obj)
           case obj
+          # strings/floats/ints: stdlib yaml_tree does NOT anchor them
+          # (its float test is load-side only) — and CBOR encode
+          # rejects the anchors the cbor profile feeds it
           when nil, true, false, ::Integer, ::Float, ::String then scalar(obj)
           when ::Symbol then @tree.new_scalar(":#{obj}", :plain) # psych emits symbols bare, never through visit_String's quoting rules
-          when ::Date, ::Time then scalar(obj) # timestamp text, never ivars
+          # stdlib visit_DateTime: the class tag carries the type (a
+          # plain timestamp re-loads as Time) — "!ruby/object:DateTime
+          # 2017-04-13 12:00:00.500000000 +09:00", to_s text, one line
+          when ::DateTime
+            anchored_scalar(obj, text: obj.strftime("%F %H:%M:%S.%9N %:z"),
+                            tag: "!ruby/object:DateTime")
+          when ::Date, ::Time then anchored_scalar(obj) # timestamp text, never ivars
           when ::Hash then visit_hash(obj)
           when ::Array then visit_array(obj)
           when ::Struct then visit_struct(obj)
@@ -101,7 +124,7 @@ module Yeptris
           if @refs[oid] < 2
             return [:none, nil]
           end
-          name = "o#{@counter += 1}"
+          name = (@counter += 1).to_s # stdlib: &1, *1
           @names[oid] = name
           [:new, name]
         end
@@ -156,7 +179,7 @@ module Yeptris
               # neutral surface alone was pinned)
               ::Yeptris::YAML::BulkBuilder.time_text(obj)
             elsif obj.is_a?(::Date)
-              obj.iso8601 # canonical calendar form (DateTime rides here too)
+              obj.iso8601 # canonical calendar form
             elsif obj.nil?
               "" # libyaml's null rendering rides bare (issue #290)
             elsif obj.is_a?(::Float)
@@ -165,7 +188,7 @@ module Yeptris
               obj.to_s
             end
           n =
-            if obj.is_a?(::String)
+            if obj.is_a?(::String) && !tag
               ::Yeptris::YAML::Builder.build_string(@tree, obj)
             else
               @tree.new_scalar(text, :plain)
@@ -220,7 +243,7 @@ module Yeptris
           m = @tree.new_mapping
           remember(strct, m)
           m.set_anchor(name) if name
-          m.set_tag(strct.class.name ? "!ruby/struct:#{strct.class.name}" : "!ruby/struct")
+          m.set_tag(strct.class.name.to_s.empty? ? "!ruby/struct" : "!ruby/struct:#{strct.class.name}")
           strct.each_pair { |k, v| m.map_add(key_text(k), visit(v)) }
           m
         end
@@ -326,6 +349,9 @@ module Yeptris
             when ::Yeptris::Psych::Nodes::Mapping then visit_mapping(node)
             else node&.to_ruby
             end
+          # stdlib register(): an anchored node's result is THE object
+          # for every alias to that anchor (scalars included)
+          anchors[node.anchor] = result if node.respond_to?(:anchor) && node.anchor
           # the domain-types post-pass (stdlib ToRuby#accept's tail):
           # registered blocks transform the revived result per node
           if node && !::Yeptris::Psych.domain_types.empty?

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?
 
@@ -299,14 +307,17 @@ module Yeptris
         (0...doc.document_count).each do |i|
           stream.children << Nodes::Builder.document_stream_child(doc, i)
         end
+        # ownership: the DOCUMENT wrapper is the sole owner — its own
+        # finalizer (pointer-only closure) frees the C memory; the
+        # stream merely references it. A tree-side finalizer closing
+        # over the wrapper raced the wrapper's sweep (#182's abort).
         stream.owner = doc
-        ObjectSpace.define_finalizer(
-          stream, proc { doc.free unless doc.freed? }
-        )
         stream
       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
 
@@ -327,6 +338,11 @@ module Yeptris
         # data anyway
         out =
           case obj
+          # DateTime < Date in ruby's hierarchy — the fast scalar
+          # path would emit it tag-less iso8601 (re-loading as Time);
+          # the visitor carries stdlib's !ruby/object:DateTime tag
+          when ::DateTime
+            Visitors::YAMLTree.new.push(obj).finish
           when nil, true, false, ::String, ::Integer, ::Float, ::Symbol, ::Date, ::Time
             Yeptris::YAML.dump(obj, header: true)
           else
@@ -442,12 +458,13 @@ module Yeptris
           @tags = tags
         end
 
-        # @api private — transfer of C ownership to this tree
+        # @api private — attach the document: the tree REFERENCES it
+        # (keeping the C memory alive while the tree is reachable);
+        # the wrapper's own finalizer is the sole freer (#182: a
+        # tree-side finalizer closing over the wrapper raced the
+        # wrapper's sweep — SIGABRT under document churn)
         def own(yeptris_doc)
           @owner = yeptris_doc
-          ObjectSpace.define_finalizer(
-            self, proc { yeptris_doc.free unless yeptris_doc.freed? }
-          )
           self
         end
 
@@ -515,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.1".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/dom/dom.c

@@ -241,6 +241,9 @@ void dom_link(yep_dom* d, uint32_t parent, uint32_t child) {
     }
     p->last_child = child;
     p->count++;
+    /* every link changes SOME container's child list (#377's cache) */
+    d->child_cache_id = UINT32_MAX;
+    d->child_cache_len = 0;
 }
 
 /* ---- mutation side tables (64-2a) ---- */
@@ -485,6 +488,9 @@ yep_dom* yep_dom_create(const yep_allocator* sys) {
      * document that decode-only consumers (CBOR load, serialize, free)
      * never touch; yep_dom_handles() materializes it on first use */
     d->handles = NULL;
+    d->child_cache = NULL;
+    d->child_cache_id = UINT32_MAX;
+    d->child_cache_len = 0;
     if (yep_mutex_init(&d->midx.mu) != 0) {
         yep_pool_destroy(pool);
         yep_free(sys, d);
@@ -513,6 +519,69 @@ struct yep_hpool* yep_dom_handles(yep_dom* d) {
     return h;
 }
 
+/* #377 (ruby #168): seq_at/map_at were O(i) sibling walks — the
+ * bindings' per-element loops made an 80k-row sequence quadratic
+ * (the relaton index: 238-328s where stdlib takes ~3s). The bulk
+ * drain (yeptris_node_children) fixed the bindings; THIS fixes the
+ * accessor: the last indexed container's child ids cache under the
+ * lazy-init mutex, O(1) after the first call. Invalidated by every
+ * child-list mutation (dom_invalidate_child_cache). */
+void dom_invalidate_child_cache(yep_dom* d) {
+    if (d == NULL) {
+        return;
+    }
+    d->child_cache_id = UINT32_MAX;
+    d->child_cache_len = 0;
+}
+
+/* Returns child id at index (UINT32_MAX when out of range); the
+ * container's child count rides *count_out. */
+uint32_t dom_indexed_child(yep_dom* d, uint32_t cid, size_t index, uint32_t* count_out) {
+    const yep_dnode* n = yep_dom_node(d, cid);
+    if (n == NULL) {
+        *count_out = 0;
+        return UINT32_MAX;
+    }
+    *count_out = n->count;
+    if (d->child_cache_id == cid) {
+        if (index < d->child_cache_len) {
+            return d->child_cache[index];
+        }
+        return UINT32_MAX;
+    }
+    /* miss: build once under the lazy-init mutex (Threads.
+     * ReadOnlySharing — concurrent first calls race here exactly like
+     * the handle pool's) */
+    yep_mutex_lock(&d->midx.mu);
+    if (d->child_cache_id != cid) {
+        yep_free(d->sys, d->child_cache);
+        d->child_cache = NULL;
+        d->child_cache_len = 0;
+        if (n->count > 0) {
+            uint32_t* arr = yep_alloc(d->sys, n->count * sizeof(uint32_t));
+            if (arr != NULL) {
+                uint32_t k = 0;
+                for (uint32_t id = n->first_child; id != UINT32_MAX && k < n->count;) {
+                    const yep_dnode* cn = yep_dom_node(d, id);
+                    if (cn == NULL) {
+                        break;
+                    }
+                    arr[k++] = id;
+                    id = cn->next_sibling;
+                }
+                d->child_cache = arr;
+                d->child_cache_len = k;
+            }
+        }
+        d->child_cache_id = cid;
+    }
+    yep_mutex_unlock(&d->midx.mu);
+    if (index < d->child_cache_len) {
+        return d->child_cache[index];
+    }
+    return UINT32_MAX;
+}
+
 void yep_dom_destroy(yep_dom* d) {
     if (d == NULL) {
         return;
@@ -523,6 +592,7 @@ void yep_dom_destroy(yep_dom* d) {
     yep_free(d->sys, d->mut_att);
     yep_free(d->sys, d->mut_depth);
     yep_hpool_destroy(d->handles);
+    yep_free(d->sys, d->child_cache);
     yep_pool_destroy(d->pool);
     yep_free(d->sys, d);
 }

data/vendor/libyeptris/src/yeptris/dom/dom.h

@@ -114,6 +114,13 @@ typedef struct yep_dom {
      * YeptrisNode wrappers here, so read-only document sharing across
      * threads is safe; parse-path pools stay single-threaded */
     struct yep_hpool* handles;
+    /* #377: the lazy indexed-children cache — child ids of the LAST
+     * container indexed via seq_at/map_at. Built once per container
+     * under the lazy-init mutex (read-only sharing), O(1) after;
+     * invalidated by every child-list mutation. NULL when idle. */
+    uint32_t* child_cache;
+    uint32_t child_cache_id; /* UINT32_MAX = empty */
+    uint32_t child_cache_len;
     yep_dnode* nodes;
     uint32_t ncount, ncap;
     uint32_t* docs; /* document root node ids */
@@ -200,6 +207,9 @@ void dom_mut_set_depth(yep_dom* d, uint32_t id, uint16_t depth);
 struct yep_hpool* yep_hpool_create(const yep_allocator* sys);
 /* Lazy handle-pool acquisition (#157): NULL dom or OOM stays NULL. */
 struct yep_hpool* yep_dom_handles(yep_dom* d);
+/* #377: the lazy indexed-children cache (seq_at/map_at's O(1) leg) */
+void dom_invalidate_child_cache(yep_dom* d);
+uint32_t dom_indexed_child(yep_dom* d, uint32_t cid, size_t index, uint32_t* count_out);
 void yep_hpool_destroy(struct yep_hpool* p);
 void* yep_hpool_alloc(struct yep_hpool* p, size_t size, size_t align);
 

data/vendor/libyeptris/src/yeptris/dom/mutate.c

@@ -268,6 +268,8 @@ static int unlink_child(yep_dom* d, uint32_t parent, uint32_t child) {
             p->last_child = c;
         }
     }
+    d->child_cache_id = UINT32_MAX; /* #377: the list changed */
+    d->child_cache_len = 0;
     d->nodes[child].next_sibling = UINT32_MAX;
     dom_mut_set_att(d, child, 0);
     p->count--;

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) {

data/vendor/libyeptris/src/yeptris/parse.c

@@ -646,11 +646,12 @@ YEPTRIS_API YeptrisNode yeptris_node_seq_at(YeptrisNode handle, size_t index) {
     if (n == NULL || n->kind != YEP_DOM_SEQUENCE || index >= n->count) {
         return NULL;
     }
-    const yep_dom* dom = ((yeptris_node*)handle)->doc->dom;
-    uint32_t id = n->first_child;
-    for (size_t i = 0; i < index && id != UINT32_MAX; i++) {
-        const yep_dnode* cur = yep_dom_node(dom, id);
-        id = cur ? cur->next_sibling : UINT32_MAX;
+    yep_dom* dom = ((yeptris_node*)handle)->doc->dom;
+    uint32_t count = 0;
+    /* the node id IS its dnode index */
+    uint32_t id = dom_indexed_child(dom, ((yeptris_node*)handle)->id, index, &count); /* #377 */
+    if (id == UINT32_MAX) {
+        return NULL;
     }
     return wrap((yeptris_node*)handle, id);
 }
@@ -685,10 +686,11 @@ YEPTRIS_API int yeptris_node_map_at(YeptrisNode handle, size_t index, YeptrisNod
         return -1;
     }
     yeptris_node* h = (yeptris_node*)handle;
-    const yep_dom* d = h->doc->dom;
-    uint32_t child = n->first_child;
-    for (size_t i = 0; i < index * 2; i++) {
-        child = d->nodes[child].next_sibling; /* pairs are key,value,… */
+    yep_dom* d = h->doc->dom;
+    uint32_t count = 0;
+    uint32_t child = dom_indexed_child(d, h->id, (size_t)index * 2, &count); /* #377 */
+    if (child == UINT32_MAX) {
+        return -1;
     }
     if (key != NULL) {
         *key = wrap(h, child);

metadata

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