leptris 1.9.199.0-arm-linux → 1.9.199.1-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1246f7d20c2b80ba4502e6185f239c6a614b8d3d7587359f4fa91da3a0d40613
-  data.tar.gz: 31cfd799241888660103004201d7cbe1dd24feea593db85373fb62b32118bdf9
+  metadata.gz: de61273fea68a6eaaa885885c05111519db55930d3d236a94f3dde8f3b2d96f6
+  data.tar.gz: 72f0bd31f62636d768d6ae180d5c10294798f0c006566510f6a6dcfbff0e902c
 SHA512:
-  metadata.gz: 6dc24866901b0eb2f1823e54f99a5b58c05966b0b9b54c8eacdb843e9055b0541be5181ee46039cb01390c7b9ef93ff06223bce1232414a6d250fbf8eea7d7b9
-  data.tar.gz: 8172f2daa4d5d3781f8ed402bfea1e1106f252d9a9be3b9116833395c3be08722b700cec518a10ab036f77c9d888e6f32ca72b5d5b1ba8b4a0eb4e78f4790216
+  metadata.gz: a4d7ac5d37da0125035785441726b64e3eaa497d5f80af169485f127bc64373cb862e596004b8fff7f874926b6b3a59860c00b3f6be2a1394e80ec9958903d46
+  data.tar.gz: aef8e4d990cebc7bf5307af0b3aa36e7e5b9a57b39fb98c74c95223f0a7e6ed12f44d59af88dd7b50fe547acb61afb7f87ab98e70fb0701b6835ad9d32ca22f9

data/ext/leptris/native/native.c

@@ -1941,6 +1941,122 @@ static VALUE nf_snapshot_rows(VALUE self, VALUE document, VALUE addr)
     return out;
 }
 
+/* ---- Struct plan executor (moxml "miles faster" round) ------------
+ * The consumer's shape compiles to spec: name (interned String) ->
+ * [Struct class, attrs Hash (name -> slot Symbol), text slot Symbol
+ * or nil, children slot Symbol or nil]. C walks the subtree
+ * pre-order, mints typed structs directly (rb_struct_new +
+ * rb_struct_aset), and attaches each to the nearest OPEN frame —
+ * exactly Moxml::Plan's semantics: an unmatched element is a
+ * barrier (its matched descendants surface at top level). Zero
+ * Ruby frames and zero intermediate rows per element. */
+static void plan_walk(void *node, int depth, VALUE spec, VALUE stack,
+                      VALUE roots)
+{
+    if (f_node_type(node) == WS_NODE_ELEMENT) {
+        const char *name_c = f_elem_name(node);
+        VALUE entry = name_c ? rb_hash_aref(spec,
+                            rb_enc_interned_str(name_c, strlen(name_c),
+                                                rb_utf8_encoding()))
+                             : Qnil;
+
+        /* Complete deeper frames: pre-order means any open frame at
+         * depth >= this element's depth belongs to an earlier
+         * subtree that ended before this row. */
+        while (RARRAY_LEN(stack) >= 2 &&
+               NUM2INT(rb_ary_entry(stack, RARRAY_LEN(stack) - 2)) >=
+                 depth) {
+            rb_ary_pop(stack);
+            rb_ary_pop(stack);
+        }
+
+        if (!NIL_P(entry)) {
+            /* volatile: keep live VALUEs on the C stack so the
+             * conservative scanner sees them on every ABI (windows
+             * x64 keeps some only in callee-saved registers). */
+            volatile VALUE klass = rb_ary_entry(entry, 0);
+            volatile VALUE attrs_spec = rb_ary_entry(entry, 1);
+            volatile VALUE text_slot = rb_ary_entry(entry, 2);
+            volatile VALUE children_slot = rb_ary_entry(entry, 3);
+            VALUE value = rb_struct_new(klass);
+
+            for (void *a = f_attr_first(node); a; a = f_attr_next(a)) {
+                const char *an = f_attr_name(a);
+                VALUE slot = an ? rb_hash_aref(attrs_spec,
+                                      rb_enc_interned_str(an, strlen(an),
+                                                          rb_utf8_encoding()))
+                                : Qnil;
+                if (!NIL_P(slot)) {
+                    const char *av = f_attr_value(node, a);
+                    rb_struct_aset(value, slot,
+                                   av ? rb_utf8_str_new_cstr(av) : Qnil);
+                }
+            }
+            if (!NIL_P(text_slot)) {
+                void *c;
+                for (c = f_first_child(node); c; c = f_next_sibling(c)) {
+                    if (f_node_type(c) == WS_NODE_TEXT) {
+                        const char *t = f_text_content(c);
+                        rb_struct_aset(value, text_slot,
+                                       t ? rb_utf8_str_new_cstr(t) : Qnil);
+                        break;
+                    }
+                }
+            }
+
+            /* attach: nearest open frame carrying a children array;
+             * barriers (unmatched ancestors) and the root surface
+             * the value at top level — Moxml::Plan's contract. */
+            if (RARRAY_LEN(stack) >= 2 &&
+                rb_ary_entry(stack, RARRAY_LEN(stack) - 1) != Qnil) {
+                rb_ary_push(rb_ary_entry(stack, RARRAY_LEN(stack) - 1),
+                            value);
+            } else {
+                rb_ary_push(roots, value);
+            }
+            RB_GC_GUARD(value);
+            RB_GC_GUARD(entry);
+
+            if (!NIL_P(children_slot)) {
+                VALUE children = rb_ary_new();
+                rb_struct_aset(value, children_slot, children);
+                rb_ary_push(stack, INT2NUM(depth));
+                rb_ary_push(stack, children);
+            }
+        } else {
+            /* unmatched: barrier frame — descendants must not
+             * attach through it (Moxml::Plan parity). */
+            rb_ary_push(stack, INT2NUM(depth));
+            rb_ary_push(stack, Qnil);
+        }
+
+        void *c;
+        for (c = f_first_child(node); c; c = f_next_sibling(c)) {
+            plan_walk(c, depth + 1, spec, stack, roots);
+        }
+    } else if (f_node_type(node) == WS_NODE_DOCTYPE ||
+               f_node_type(node) == 9) {
+        void *dc = f_first_child(node);
+        while (dc) {
+            plan_walk(dc, depth, spec, stack, roots);
+            dc = f_next_sibling(dc);
+        }
+    }
+}
+
+static VALUE nf_plan_structs(VALUE self, VALUE document, VALUE addr,
+                             VALUE spec)
+{
+    (void)self;
+    (void)document;
+    VALUE roots = rb_ary_new();
+    VALUE stack = rb_ary_new();
+    plan_walk((void *)(uintptr_t)NUM2ULL(addr), 0, spec, stack, roots);
+    RB_GC_GUARD(spec);
+    RB_GC_GUARD(stack);
+    return roots;
+}
+
 /* ---- inner_html in one C pass (TODO.perf/18) --------------------
  * Serializes the receiver's children into one growable buffer:
  * elements via leptris_element_serialize_into (the same opts the
@@ -2490,6 +2606,8 @@ void Init_native(void)
                               nf_snapshot_subtree, 2);
     rb_define_module_function(m_native, "snapshot_rows",
                               nf_snapshot_rows, 2);
+    rb_define_module_function(m_native, "plan_structs",
+                              nf_plan_structs, 3);
     rb_define_module_function(m_native, "doc_handle_attach",
                               nf_doc_handle_attach, 1);
     rb_define_module_function(m_native, "doc_handle_release",

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.199.0"
+  VERSION = "1.9.199.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.199.0
+  version: 1.9.199.1
 platform: arm-linux
 authors:
 - Ribose Inc.