create inspect method for lazy values

Author: Asmod4n

src/mrb_cbor.c

@@ -3012,9 +3012,6 @@ path_walk_wildcards(mrb_state *mrb, mrb_value node,
   mrb_value resolved;
   uint8_t major;
 
-  /* Chase sharedref chain until we land on a concrete array header.
-   * lazy_resolve_tags handles Tag 28 registration and Tag 29 resolution;
-   * we just need to re-seat `node` on each sharedref target and retry. */
   for (;;) {
     cbor_lazy_t *p = mrb_data_get_ptr(mrb, node, &cbor_lazy_type);
     Reader r;
@@ -3024,28 +3021,36 @@ path_walk_wildcards(mrb_state *mrb, mrb_value node,
     mrb_value sharedrefs = mrb_iv_get(mrb, node, MRB_SYM(sharedrefs));
     mrb_assert(mrb_array_p(sharedrefs));
 
-    mrb_int sharedrefs_before = RARRAY_LEN(sharedrefs);
     major = lazy_resolve_tags(mrb, &r, p->buf, sharedrefs, &resolved);
 
     if (major == 4) {
       mrb_int   len        = cbor_len_to_mrb_int(mrb, read_cbor_uint(mrb, &r, r.info));
       mrb_int   nseg       = RARRAY_LEN(segments);
       mrb_value next_steps = mrb_ary_ref(mrb, segments, depth + 1);
       mrb_bool  is_leaf    = (depth == nseg - 2);
+      mrb_value kcache     = mrb_iv_get(mrb, node, MRB_SYM(kcache));
+      mrb_value results    = mrb_ary_new_capa(mrb, len);
+      int       arena      = mrb_gc_arena_save(mrb);
 
-      /* If lazy_resolve_tags consumed a Tag28 and registered the inner Lazy,
-       * use that Lazy (which starts at the array header, not the Tag28 byte)
-       * for cbor_lazy_aref calls. Without this, each call re-reads the Tag28
-       * and pushes a duplicate into sharedrefs, corrupting Tag29 resolution. */
-      mrb_value work_node = (RARRAY_LEN(sharedrefs) > sharedrefs_before)
-        ? mrb_ary_ref(mrb, sharedrefs, RARRAY_LEN(sharedrefs) - 1)
-        : node;
-
-      mrb_value results = mrb_ary_new_capa(mrb, len);
-      mrb_int arena = mrb_gc_arena_save(mrb);
+      /* All elements cached iff kcache has at least len entries.
+       * In that case r.p tracking and skip_cbor are not needed. */
+      mrb_bool fully_cached = (mrb_hash_size(mrb, kcache) >= len);
 
       for (mrb_int i = 0; i < len; i++) {
-        mrb_value elem = cbor_lazy_aref(mrb, work_node, mrb_convert_mrb_int(mrb, i));
+        mrb_value idx_v = mrb_convert_mrb_int(mrb, i);
+        mrb_value elem  = mrb_hash_fetch(mrb, kcache, idx_v, mrb_undef_value());
+
+        if (mrb_undef_p(elem)) {
+          /* Cache miss — r.p is at element i, create lazy and advance. */
+          mrb_int elem_offset = cbor_pdiff(mrb, r.p, r.base);
+          elem = cbor_lazy_new(mrb, p->buf, elem_offset, sharedrefs);
+          mrb_hash_set(mrb, kcache, idx_v, elem);
+        }
+
+        if (!fully_cached) {
+          skip_cbor(mrb, &r, p->buf, sharedrefs);
+        }
+
         mrb_value next = path_walk_steps(mrb, elem, next_steps);
         mrb_value val  = is_leaf
           ? cbor_lazy_value(mrb, next)
@@ -3058,7 +3063,6 @@ path_walk_wildcards(mrb_state *mrb, mrb_value node,
     }
 
     if (major == 0xFF) {
-      /* Tag 29 resolved — re-seat on target and loop. */
       if (!mrb_data_check_get_ptr(mrb, resolved, &cbor_lazy_type))
         mrb_raise(mrb, E_TYPE_ERROR,
           "CBOR::Path [*]: sharedref target is not indexable");
@@ -3095,6 +3099,16 @@ mrb_cbor_path_at(mrb_state *mrb, mrb_value self)
     : path_walk_wildcards(mrb, node, segments, 0);
 }
 
+static mrb_value
+cbor_lazy_inspect(mrb_state *mrb, mrb_value self)
+{
+  cbor_lazy_t *p = mrb_data_get_ptr(mrb, self, &cbor_lazy_type);
+  mrb_value sub = mrb_str_byte_subseq(mrb, p->buf, p->offset,
+                    RSTRING_LEN(p->buf) - p->offset);
+  return mrb_funcall_argv(mrb, mrb_obj_value(mrb_module_get_id(mrb, MRB_SYM(CBOR))),
+                          MRB_SYM(diagnose), 1, &sub);
+}
+
 MRB_BEGIN_DECL
 
 MRB_API mrb_value
@@ -3209,6 +3223,7 @@ mrb_mruby_cbor_gem_init(mrb_state* mrb)
   mrb_define_method_id(mrb, lazy, MRB_OPSYM(aref), cbor_lazy_aref_m, MRB_ARGS_REQ(1));
   mrb_define_method_id(mrb, lazy, MRB_SYM(value),  cbor_lazy_value,  MRB_ARGS_NONE());
   mrb_define_method_id(mrb, lazy, MRB_SYM(dig),    cbor_lazy_dig,    MRB_ARGS_ANY());
+  mrb_define_method_id(mrb, lazy, MRB_SYM(inspect),cbor_lazy_inspect,MRB_ARGS_NONE());
 
   struct RClass *path =
     mrb_define_class_under_id(mrb, cbor, MRB_SYM(Path), mrb->object_class);

test/test.rb

@@ -4397,3 +4397,68 @@ class MutualB
   assert_equal [1, 2], lazy["ref"].value
 end
 
+assert('CBOR::Path wildcard + direct aref share same element lazies') do
+  docs = (0...5).map { |i| { "id" => i, "name" => "item#{i}" } }
+  buf  = CBOR.encode({ "items" => docs })
+  path = CBOR::Path.compile("$.items[*].name")
+  lazy = CBOR.decode_lazy(buf)
+
+  # path.at populates kcache for each element
+  path.at(lazy)
+
+  # direct aref must return same Lazy object (cache hit)
+  items = lazy["items"]
+  (0...5).each do |i|
+    via_path_elem  = lazy["items"][i]["name"]
+    via_aref_elem  = items[i]["name"]
+    via_dig_elem   = lazy.dig("items", i, "name")
+    assert_same via_path_elem, via_aref_elem
+    assert_same via_aref_elem, via_dig_elem
+  end
+end
+
+assert('CBOR::Path wildcard + .value cache consistent across apis') do
+  docs = (0...5).map { |i| { "id" => i, "name" => "item#{i}" } }
+  buf  = CBOR.encode({ "items" => docs })
+  path = CBOR::Path.compile("$.items[*].name")
+  lazy = CBOR.decode_lazy(buf)
+
+  # materialize via path first
+  names_via_path = path.at(lazy)
+
+  # then via direct aref + value — must be same Ruby objects (vcache hit)
+  (0...5).each do |i|
+    via_aref = lazy["items"][i]["name"].value
+    assert_same names_via_path[i], via_aref
+  end
+end
+
+assert('direct aref first, then path.at reuses populated kcache') do
+  docs = (0...5).map { |i| { "id" => i, "name" => "item#{i}" } }
+  buf  = CBOR.encode({ "items" => docs })
+  path = CBOR::Path.compile("$.items[*].name")
+  lazy = CBOR.decode_lazy(buf)
+
+  # warm kcache via direct aref first
+  pre = (0...5).map { |i| lazy["items"][i]["name"] }
+
+  # path.at must hit the existing cache — same Lazy objects
+  path.at(lazy)
+  (0...5).each do |i|
+    assert_same pre[i], lazy["items"][i]["name"]
+  end
+end
+
+assert('dig first, then path.at reuses populated kcache') do
+  docs = (0...5).map { |i| { "id" => i, "name" => "item#{i}" } }
+  buf  = CBOR.encode({ "items" => docs })
+  path = CBOR::Path.compile("$.items[*].name")
+  lazy = CBOR.decode_lazy(buf)
+
+  pre = (0...5).map { |i| lazy.dig("items", i, "name") }
+
+  path.at(lazy)
+  (0...5).each do |i|
+    assert_same pre[i], lazy.dig("items", i, "name")
+  end
+end