yeptris 0.6.14.1 → 0.6.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60e8ec13d8221947494e0f163b57a619a3bb6d4f179f53d3f9b324e0ae0a4ffb
-  data.tar.gz: 6eda638121e069206be5d900cc044c942b84e74989d6482255b0e9177aab13f4
+  metadata.gz: b1326388a6f59887d9b8f541ec6f4c835071ca05f4821d429a82b8acc1a990e2
+  data.tar.gz: 521f5abbcebb9611a0c67699b1952e72d3790d228fe606148f095d622f5b4387
 SHA512:
-  metadata.gz: dbe32b83a5b017191c37a5978325516a5f99a7d85819ead1dcd97c030fec14f586acfb6d5965275cf1416c74f4dbeecb08abea77074ce769f51340ef3c1e9a7a
-  data.tar.gz: 9b6db9635acbdc9e83017626594b8417fec8c2953e38d17878bf2e99e5a4e0976f4087862890f78a23155ea3eb34d8ca8afeb87e536991fa80091b626e40875e
+  metadata.gz: 7b6e36f35a32d480af8635023bbaf173194e8295e34851ae53ec8121cdf872e9d71c4877f70cc94d1ee62d0d22e4f74e868edc7746b2fbbd9d66af47f31daad0
+  data.tar.gz: 21a442ef4c99c57f46b837af822db3d98434c476b5a0b7c56d52f03bbfac0c8849be28b2a7fd2109a95b15a80ea6eda9116c3631ff5c6faff2d134e5b2a861fc

data/lib/yeptris/document.rb

@@ -20,24 +20,29 @@ 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)
     yaml = Yeptris.read_input(yaml)
     yaml = yaml.to_s
+    status = ::FFI::MemoryPointer.new(:int)
     doc =
       if schema == :core_12 && max_depth.zero?
-        Yeptris::FFI.yeptris_parse(yaml, yaml.bytesize, nil)
+        Yeptris::FFI.yeptris_parse(yaml, yaml.bytesize, status)
       else
         opts = Yeptris::FFI::ParseOptions.new
         opts[:schema] = schema == :compat_11 ? Yeptris::FFI::SCHEMA_11_COMPAT : Yeptris::FFI::SCHEMA_12_CORE
         opts[:max_depth] = max_depth
-        Yeptris::FFI.yeptris_parse_ex(yaml, yaml.bytesize, opts, nil)
+        Yeptris::FFI.yeptris_parse_ex(yaml, yaml.bytesize, opts, status)
       end
     if doc.null?
-      # the status out-param is skipped: the thread-local error
-      # channel carries the failure detail (measurable on small docs)
+      # NULL + OK is the legal empty stream (no documents): nil, like
+      # stdlib. The status out-param is the discriminator — the TLS
+      # error message cannot serve (a stale error from an earlier
+      # parse persists on the thread).
+      return nil if status.read_int.zero?
+
       raise Yeptris::ParseError,
             "parse failed: #{Yeptris::FFI.last_error_message}"
     end
@@ -83,6 +88,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
@@ -216,12 +224,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

@@ -276,6 +276,31 @@ class Yeptris::Node
     alive { Yeptris::FFI.yeptris_node_id(@c_ptr) }
   end
 
+  # The marshal fast path (TODO.restructure/21; #178): one C call
+  # turns this subtree into Marshal 4.8 bytes — Marshal.load builds
+  # the Ruby objects in C, no per-node FFI. nil when the document
+  # carries constructs the format cannot express (merge keys,
+  # timestamps, tagged revivals): the caller walks instead. Raises
+  # ParseError on engine errors (not on the bail).
+  def marshal_fast
+    return nil unless Yeptris::FFI::MARSHAL
+
+    out_p = ::FFI::MemoryPointer.new(:pointer)
+    olen_p = ::FFI::MemoryPointer.new(:size_t)
+    st = alive { Yeptris::FFI.yeptris_marshal_node(@c_ptr, out_p, olen_p) }
+    if st == Yeptris::FFI::ERROR_UNSUPPORTED
+      nil
+    elsif st != Yeptris::FFI::OK
+      raise Yeptris::ParseError, Yeptris::FFI.last_error_message
+    else
+      bytes = out_p.read_pointer.read_bytes(olen_p.read_uint64)
+      bytes.force_encoding(Encoding::ASCII_8BIT)
+      ::Marshal.load(bytes)
+    end
+  ensure
+    Yeptris::FFI.yeptris_marshal_free(out_p.read_pointer) if out_p
+  end
+
   def to_ruby(memo = nil)
     # readonly documents memoize per node: a second materialization
     # returns the SAME object (the readonly cache is the ground truth
@@ -293,25 +318,7 @@ class Yeptris::Node
     # Falls back to the per-node FFI walk on constructs the format
     # cannot express (merge keys, timestamps) and on older builds.
     if Yeptris::FFI::MARSHAL && memo.nil?
-      result =
-        begin
-          out_p = ::FFI::MemoryPointer.new(:pointer)
-          olen_p = ::FFI::MemoryPointer.new(:size_t)
-          st = Yeptris::FFI.yeptris_marshal_node(@c_ptr, out_p, olen_p)
-          if st == Yeptris::FFI::ERROR_UNSUPPORTED
-            nil
-          elsif st != Yeptris::FFI::OK
-            raise Yeptris::ParseError, Yeptris::FFI.last_error_message
-          else
-            buf = out_p.read_pointer
-            len = olen_p.read_uint64
-            bytes = buf.read_bytes(len)
-            bytes.force_encoding(Encoding::ASCII_8BIT)
-            ::Marshal.load(bytes)
-          end
-        ensure
-          Yeptris::FFI.yeptris_marshal_free(out_p.read_pointer) if out_p
-        end
+      result = marshal_fast
       unless result.nil?
         @document.readonly_memo[node_id] = result if @document.readonly?
         return result
@@ -332,7 +339,32 @@ class Yeptris::Node
       h = {}
       memo[node_id] = h
       each_pair do |k, v|
-        h[k.to_ruby_key] = v.to_ruby(memo)
+        key = k.to_ruby_key
+        val = v.to_ruby(memo)
+        if key == "<<" && k.tag != "tag:yaml.org,2002:str"
+          # stdlib revive_hash's merge branch: the VALUE's node kind
+          # picks the arm; every merge is TypeError-guarded (a bad
+          # element keeps the whole '<<' pair literal)
+          if v.kind == :alias || v.mapping?
+            begin
+              h.merge!(val)
+            rescue ::TypeError
+              h[key] = val
+            end
+          elsif v.sequence?
+            begin
+              merged = {}
+              val.reverse_each { |e| merged.merge!(e) }
+              h.merge!(merged)
+            rescue ::TypeError
+              h[key] = val
+            end
+          else
+            h[key] = val
+          end
+        else
+          h[key] = val
+        end
       end
       h
     when :sequence
@@ -342,7 +374,11 @@ class Yeptris::Node
       a
     when :alias
       t = alias_target
-      t.nil? ? nil : t.to_ruby(memo)
+      if t.nil?
+        raise ::Yeptris::Psych::AnchorNotDefined,
+              "Unknown anchor: #{anchor}"
+      end
+      t.to_ruby(memo)
     else
       scalar_to_ruby
     end
@@ -358,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)
@@ -188,6 +211,13 @@ module Yeptris
               key_node = @tree.new_scalar("", :single_quoted)
               key_node.set_tag("!")
               m.map_add_node(key_node, visit(v))
+            elsif k.is_a?(::String) && k == "<<"
+              # stdlib yaml_tree: a literal chevron key carries the
+              # explicit !!str tag (single-quoted) so it does not
+              # re-load as a merge
+              key_node = @tree.new_scalar("<<", :single_quoted)
+              key_node.set_tag("!!str")
+              m.map_add_node(key_node, visit(v))
             else
               m.map_add(key_text(k), visit(v))
             end
@@ -213,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
@@ -319,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?
@@ -415,10 +448,38 @@ module Yeptris
           end
         end
 
+        # stdlib visit_hash's merge branch, verbatim in structure: the
+        # key's SHAPE decides (an explicit !!str '<<' is a literal key,
+        # not a merge), the VALUE's node kind picks the arm, and every
+        # merge is TypeError-guarded (a bad element keeps the whole
+        # '<<' pair literal — merges are all-or-nothing).
         def hash_into(h, node)
           anchors[node.anchor] = h if node.anchor
           node.children.each_slice(2) do |k, v|
-            h[visit(k)] = visit(v)
+            key = visit(k)
+            val = visit(v)
+            if key == "<<" && k.tag != "tag:yaml.org,2002:str"
+              case v
+              when ::Yeptris::Psych::Nodes::Alias, ::Yeptris::Psych::Nodes::Mapping
+                begin
+                  h.merge!(val)
+                rescue ::TypeError
+                  h[key] = val
+                end
+              when ::Yeptris::Psych::Nodes::Sequence
+                begin
+                  merged = {}
+                  val.reverse_each { |value| merged.merge!(value) }
+                  h.merge!(merged)
+                rescue ::TypeError
+                  h[key] = val
+                end
+              else
+                h[key] = val
+              end
+            else
+              h[key] = val
+            end
           end
           h
         end

data/lib/yeptris/psych.rb

@@ -91,6 +91,9 @@ module Yeptris
     # object instance exists.
     autoload :Encodable, "yeptris/psych/encodable"
     class Error < StandardError; end
+
+    # stdlib psych 5: a *foo with no matching &foo anchor
+    class AnchorNotDefined < Error; end
     # Psych's exact interface (issue #32): same constructor arity,
     # same reader set (file/line/column/offset/problem/context), same
     # message shape — drop-in consumers' rescues and constructors
@@ -143,6 +146,31 @@ module Yeptris
       # !ruby/set, encode_with/init_with, alias identity. Plain-data
       # loads should use load/safe_load (the Materializer fast path).
       def unsafe_load(yaml, **)
+        # #178: the marshal fast path. Nodes::Builder's tree is per-node
+        # FFI (kind/tag/anchor/value + a walk per container) — the whole
+        # 11 MB relaton index paid ~9.6 s there. When the document is
+        # plain data (no timestamps/merge keys/tagged revivals), ONE C
+        # call materializes the tree as Marshal bytes and Marshal.load
+        # builds the objects in C (~1 s end to end). Construct-heavy
+        # documents keep the full revival walk below, byte for byte.
+        if Yeptris::FFI::MARSHAL && ::Yeptris::Psych.domain_types.empty?
+          begin
+            doc = ::Yeptris::Document.parse(yaml, schema: :compat_11)
+            return nil if doc.nil? || doc.document_count.zero?
+
+            root = doc.root(0)
+            fast = root&.marshal_fast
+            unless fast.nil?
+              doc.free
+              return fast
+            end
+            tree = Nodes::Builder.document(doc) # ownership: the tree frees
+            return Visitors::ToRuby.visit(tree.children.first)
+          rescue ::Yeptris::ParseError => e
+            doc&.free unless doc&.freed?
+            translate_parse_error(e)
+          end
+        end
         tree = parse(yaml)
         return nil if tree.nil?
 
@@ -150,11 +178,16 @@ module Yeptris
       end
 
       def safe_load(yaml, permitted_classes: [::Date, ::Time], aliases: false, **)
-        doc = Yeptris::Document.parse(yaml, schema: :compat_11)
         begin
+          doc = Yeptris::Document.parse(yaml, schema: :compat_11)
+          return nil if doc.nil? # the legal empty stream
+
           force_utf8_scalars(walk_safe(doc.root(0), permitted_classes, aliases))
+        rescue ::Yeptris::ParseError => e
+          doc&.free unless doc&.freed?
+          translate_parse_error(e)
         ensure
-          doc.free
+          doc&.free
         end
       end
 
@@ -230,6 +263,8 @@ module Yeptris
         # children share one C document, so their handles would all
         # resolve to the first document's tree
         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 }
         ensure
@@ -238,9 +273,18 @@ module Yeptris
       end
 
       # The first document's node tree (no Ruby materialization).
+      def translate_parse_error(e)
+        # yeptris rejects *foo without &foo at PARSE time (stdlib
+        # raises at visit) — surface it as stdlib's class so
+        # consumers' rescues keep working
+        raise AnchorNotDefined, e.message if e.message.include?("undefined anchor")
+
+        raise SyntaxError.from_parse_error(e)
+      end
+
       def parse(yaml)
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
-        return nil if doc.document_count.zero?
+        return nil if doc.nil? || doc.document_count.zero?
 
         Nodes::Builder.document(doc)
       rescue Yeptris::ParseError => e
@@ -249,16 +293,17 @@ module Yeptris
 
       def parse_stream(yaml)
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
-        return nil if doc.document_count.zero?
+        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)
         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)
@@ -283,6 +328,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
@@ -398,12 +448,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
 

data/lib/yeptris/yaml/descriptor.rb

@@ -33,6 +33,8 @@ class Yeptris::YAML::Descriptor < ::Yeptris::JSON::Descriptor
   def walk(yaml)
     src = ::Yeptris.read_input(yaml).to_s
     doc = ::Yeptris::Document.parse(src, schema: @schema)
+    return [] if doc.nil? # the legal empty stream
+
     begin
       st = ::FFI::MemoryPointer.new(:int)
       raw = ::Yeptris::FFI.yeptris_document_plan_walk(doc.c_ptr, @handle, st)

data/lib/yeptris/yaml.rb

@@ -73,7 +73,7 @@ module Yeptris
     # Parses without materializing: the first document's root Node.
     def parse(yaml, schema: :core_12)
       doc = Document.parse(yaml, schema: schema)
-      return nil if doc.document_count.zero?
+      return nil if doc.nil? || doc.document_count.zero?
 
       doc.root(0)
     end
@@ -177,6 +177,14 @@ module Yeptris
                 off[0] += 1
               elsif k.is_a?(Symbol)
                 scalar(":#{k}", STYLE_PLAIN, emit, blob, off)
+              elsif k.is_a?(String) && k == "<<"
+                # stdlib yaml_tree: a literal chevron key carries the
+                # explicit !!str tag (single-quoted) so it does not
+                # re-load as a merge
+                scalar("<<", STYLE_SQ, emit, blob, off)
+                emit.call(BUILD_TAG, 0, off[0], 5)
+                blob << "!!str"
+                off[0] += 5
               elsif k.is_a?(String)
                 place(k, emit, blob, off, seen)
               else
@@ -343,6 +351,12 @@ module Yeptris
               key_node = doc.new_scalar("", :single_quoted)
               key_node.set_tag("!")
               m.map_add_node(key_node, build(doc, v, seen))
+            elsif k.is_a?(::String) && k == "<<"
+              # stdlib yaml_tree: a literal chevron key carries the
+              # explicit !!str tag so it does not re-load as a merge
+              key_node = doc.new_scalar("<<", :single_quoted)
+              key_node.set_tag("!!str")
+              m.map_add_node(key_node, build(doc, v, seen))
             else
               m.map_add(key_text(k), build(doc, v, seen))
             end

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.14.1".freeze
+  VERSION = "0.6.15.2".freeze
   # The error hierarchy lives in THIS file (the parent namespace's
   # own file): nested constants do not trigger a parent-constant
   # autoload, and the law forbids internal requires — defining the

data/vendor/libyeptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(yeptris
-    VERSION 0.6.14
+    VERSION 0.6.15
     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/marshal.c

@@ -721,6 +721,34 @@ YEPTRIS_API YeptrisStatus yeptris_marshal(const char* data, size_t len, YeptrisS
     return st;
 }
 
+/* #178 (ruby #168's fast path): the value records carry the resolver's
+ * verdict, NOT the source's explicit tag — a `!ruby/object` mapping
+ * would marshal as a plain hash, silently dropping the tag (psych's
+ * visitor revives it). One cheap pre-walk: any explicitly tagged node
+ * in the subtree → UNSUPPORTED, the host walks. Explicit CORE tags
+ * (!!str and friends) ride the same bail — correct, just conservative;
+ * bulk data is untagged. */
+static int dom_subtree_tagged(const yep_dom* d, uint32_t id) {
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n == NULL) {
+        return 0;
+    }
+    if (n->tag.len != 0) {
+        return 1;
+    }
+    for (uint32_t c = n->first_child; c != UINT32_MAX;) {
+        const yep_dnode* cn = yep_dom_node(d, c);
+        if (cn == NULL) {
+            break;
+        }
+        if (dom_subtree_tagged(d, c) != 0) {
+            return 1;
+        }
+        c = cn->next_sibling;
+    }
+    return 0;
+}
+
 YEPTRIS_API YeptrisStatus yeptris_marshal_node(YeptrisNode node, char** out, size_t* out_len) {
     if (node == NULL || out == NULL || out_len == NULL) {
         return YEPTRIS_ERROR_ARG;
@@ -728,6 +756,12 @@ YEPTRIS_API YeptrisStatus yeptris_marshal_node(YeptrisNode node, char** out, siz
     *out = NULL;
     *out_len = 0;
     yeptris_node* h = (yeptris_node*)node;
+    if (dom_subtree_tagged(h->doc->dom, h->id) != 0) {
+        yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
+                      "marshal: explicitly tagged node not expressible; "
+                      "fall back to the value walk");
+        return YEPTRIS_ERROR_UNSUPPORTED;
+    }
     yep_value_ctx* c = NULL;
     if (yep_values_from_dom(h->doc->dom, h->id, 0, &c) != 0) {
         return YEPTRIS_ERROR_MEMORY;

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.14.1
+  version: 0.6.15.2
 platform: ruby
 authors:
 - Ribose Inc.