leptris 1.9.199.0 → 1.9.199.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7317a3a059f59af92c730eda04a9793104d627f4929db5298756be47f318817
-  data.tar.gz: 121b3049b4be8b70aa1e6244f2140f351039794ea04a0bf1f09e40a23f366453
+  metadata.gz: bea70279fbfb8a49550bb7ce0782437960861749683fa0df0bcaee0064830b6d
+  data.tar.gz: 1ba8dede4c87e93e8812154daef28eed7f4d4544e83534e14f913279ec0316ba
 SHA512:
-  metadata.gz: a4dd3fb633b04367c5099f43c9d2b1d6531bc790bb1aa93bc0e273d6232409e780d71e458d76129992f74cb8e5522959b14636f0d74855570d242fba086c93c5
-  data.tar.gz: 6fdbbe9dc7e1b92c06774fd92413989574c6505f102e086d4a9919bac76cf80432b688fe94347a7404f29af26808ccd2a4f756d0afa5da3fcd165ce8294e3093
+  metadata.gz: 780cc666ddd610cdddcb277b1fd4b0c65f460158053772f406d387a48e97ec4d4c917d22500ab356cf21f373605089d23f4e17a3828324a6c3fd943948ded044
+  data.tar.gz: 7103eb627d5df66e146486922725f4919b84668f619a75d4a3379668962cccb8bcb7d0798ac422ac94bdf11131b995b5d44ca4f887cee6c4aeb39e8a023467f8

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: ruby
 authors:
 - Ribose Inc.