makiri 0.2.0 → 0.3.0

data/ext/makiri/glue/ruby_node_set.c

@@ -4,20 +4,41 @@
 #include <stdint.h>
 
 /* MKR_NODE_SET_MAX (the per-set node cap, shared with the CSS/XPath glue) is
- * defined in glue.h. Every node-collecting path — tree walks
- * (children / element_children / attribute_nodes), XPath, and CSS — fails
+ * defined in glue.h. Every node-collecting path - tree walks
+ * (children / element_children / attribute_nodes), XPath, and CSS - fails
  * closed at that bound instead of growing without limit. */
 
 /* A NodeSet is a plain dynamic array of Lexbor node pointers plus a keepalive
  * reference to the owning Document. Nodes are owned by the document arena, so
  * marking the document keeps them all alive. */
+/* The stored nodes are mkr_raw_node_t* (representation-opaque; see glue.h): the
+ * set never dereferences them, it only compares them for identity and, when
+ * vending a node, casts to the representation named by doc_is_xml. This keeps an
+ * XML set from ever reading its mkr_xml_node_t* pointers as lxb_dom_node_t. */
 typedef struct {
-    lxb_dom_node_t **nodes;
+    mkr_raw_node_t **nodes;
     size_t           count;
     size_t           cap;
     VALUE            document;
+    int              doc_is_xml;  /* cached once: the stored pointers are
+                                   * mkr_xml_node_t* (wrap as Makiri::XML::*) */
 } mkr_node_set_data_t;
 
+/* Wrap a stored node into a Ruby Node, choosing the representation by the set's
+ * (fixed) document kind - an XML document's nodes are custom mkr_xml_node_t. This
+ * is the ONLY place a stored raw node is cast back to a typed pointer, and the
+ * cast is justified by doc_is_xml. The kind is cached at construction so this
+ * stays a single branch per node (a per-node is_kind_of/parsed-kind probe would
+ * regress the hot traversal path). */
+static VALUE
+mkr_node_set_wrap(const mkr_node_set_data_t *s, mkr_raw_node_t *node)
+{
+    if (s->doc_is_xml) {
+        return mkr_wrap_xml_node((struct mkr_xml_node *)node, s->document);
+    }
+    return mkr_wrap_html_node((lxb_dom_node_t *)node, s->document);
+}
+
 static void
 mkr_node_set_gc_mark(void *ptr)
 {
@@ -41,7 +62,7 @@ mkr_node_set_memsize(const void *ptr)
     const mkr_node_set_data_t *s = (const mkr_node_set_data_t *)ptr;
     size_t nodes_bytes;
     size_t total;
-    if (!mkr_size_mul(s->cap, sizeof(lxb_dom_node_t *), &nodes_bytes)) {
+    if (!mkr_size_mul(s->cap, sizeof(mkr_raw_node_t *), &nodes_bytes)) {
         return sizeof(*s);
     }
     if (!mkr_size_add(sizeof(*s), nodes_bytes, &total)) {
@@ -62,15 +83,16 @@ mkr_node_set_new(VALUE document)
     mkr_node_set_data_t *s;
     VALUE obj = TypedData_Make_Struct(mkr_cNodeSet, mkr_node_set_data_t,
                                       &mkr_node_set_type, s);
-    s->nodes    = NULL;
-    s->count    = 0;
-    s->cap      = 0;
-    s->document = document;
+    s->nodes      = NULL;
+    s->count      = 0;
+    s->cap        = 0;
+    s->document   = document;
+    s->doc_is_xml = rb_obj_is_kind_of(document, mkr_cXmlDocument) ? 1 : 0;
     return obj;
 }
 
 void
-mkr_node_set_push(VALUE rb_set, lxb_dom_node_t *node)
+mkr_node_set_push(VALUE rb_set, mkr_raw_node_t *node)
 {
     mkr_node_set_data_t *s;
     TypedData_Get_Struct(rb_set, mkr_node_set_data_t, &mkr_node_set_type, s);
@@ -85,10 +107,10 @@ mkr_node_set_push(VALUE rb_set, lxb_dom_node_t *node)
          * overflow-checked (count * size) allocation while keeping the buffer
          * GC-accounted and paired with xfree in gc_free. */
         size_t new_cap;
-        if (!mkr_grow_capacity(s->cap, s->count + 1, sizeof(lxb_dom_node_t *), &new_cap)) {
+        if (!mkr_grow_capacity(s->cap, s->count + 1, sizeof(mkr_raw_node_t *), &new_cap)) {
             rb_raise(mkr_eError, "node set capacity overflow");
         }
-        s->nodes = xrealloc2(s->nodes, new_cap, sizeof(lxb_dom_node_t *));
+        s->nodes = xrealloc2(s->nodes, new_cap, sizeof(mkr_raw_node_t *));
         s->cap = new_cap;
     }
     s->nodes[s->count++] = node;
@@ -102,21 +124,52 @@ mkr_node_set_length(VALUE self)
     return ULONG2NUM(s->count);
 }
 
-/* set[i] -> Node or nil. Negative indices count from the end. */
+/* A new NodeSet from the [beg, beg+len) run of `s` (caller has clamped them to
+ * [0, count]). */
+static VALUE
+mkr_node_set_slice(mkr_node_set_data_t *s, long beg, long len)
+{
+    VALUE result = mkr_node_set_new(s->document);
+    for (long i = 0; i < len; i++) {
+        mkr_node_set_push(result, s->nodes[beg + i]);
+    }
+    return result;
+}
+
+/* set[i]               -> Node or nil (negative indices count from the end).
+ * set[start, length]   -> a new NodeSet (nil if start is out of range).
+ * set[range]           -> a new NodeSet (nil if the range start is out of range).
+ * Mirrors Array#[]. */
 static VALUE
-mkr_node_set_aref(VALUE self, VALUE rb_index)
+mkr_node_set_aref(int argc, VALUE *argv, VALUE self)
 {
     mkr_node_set_data_t *s;
     TypedData_Get_Struct(self, mkr_node_set_data_t, &mkr_node_set_type, s);
-
-    long i = NUM2LONG(rb_index);
-    if (i < 0) {
-        i += (long)s->count;
+    long count = (long)s->count;
+
+    if (argc == 2) {                       /* set[start, length] */
+        long beg = NUM2LONG(argv[0]);
+        long len = NUM2LONG(argv[1]);
+        if (beg < 0) beg += count;
+        if (beg < 0 || beg > count || len < 0) return Qnil;
+        if (len > count - beg) len = count - beg;
+        return mkr_node_set_slice(s, beg, len);
     }
-    if (i < 0 || (size_t)i >= s->count) {
-        return Qnil;
+
+    rb_check_arity(argc, 1, 2);
+
+    if (rb_obj_is_kind_of(argv[0], rb_cRange)) {
+        long beg, len;
+        if (rb_range_beg_len(argv[0], &beg, &len, count, 0) != Qtrue) {
+            return Qnil;                   /* start out of range */
+        }
+        return mkr_node_set_slice(s, beg, len);
     }
-    return mkr_wrap_node(s->nodes[i], s->document);
+
+    long i = NUM2LONG(argv[0]);
+    if (i < 0) i += count;
+    if (i < 0 || i >= count) return Qnil;
+    return mkr_node_set_wrap(s, s->nodes[i]);
 }
 
 static VALUE
@@ -128,7 +181,7 @@ mkr_node_set_each(VALUE self)
     RETURN_ENUMERATOR(self, 0, 0);
 
     for (size_t i = 0; i < s->count; i++) {
-        rb_yield(mkr_wrap_node(s->nodes[i], s->document));
+        rb_yield(mkr_node_set_wrap(s, s->nodes[i]));
     }
     return self;
 }
@@ -144,8 +197,24 @@ mkr_node_set_get(VALUE v)
     return s;
 }
 
+/* The "other" operand of a set operation, requiring it to share +s+'s document.
+ * A result NodeSet borrows exactly one document VALUE (GC keepalive) and one
+ * representation flag (HTML vs XML) to wrap its nodes; mixing two documents -
+ * which also means possibly mixing HTML and XML - would wrap a node under the
+ * wrong representation and fail to keep its document alive. Fail closed instead
+ * of silently producing a corrupt set. */
+static mkr_node_set_data_t *
+mkr_node_set_other(const mkr_node_set_data_t *s, VALUE other)
+{
+    mkr_node_set_data_t *o = mkr_node_set_get(other);
+    if (o->document != s->document) {
+        rb_raise(mkr_eError, "cannot combine node sets from different documents");
+    }
+    return o;
+}
+
 static int
-mkr_node_set_member(const mkr_node_set_data_t *s, const lxb_dom_node_t *n)
+mkr_node_set_member(const mkr_node_set_data_t *s, const mkr_raw_node_t *n)
 {
     for (size_t i = 0; i < s->count; i++) {
         if (s->nodes[i] == n) {
@@ -158,10 +227,10 @@ mkr_node_set_member(const mkr_node_set_data_t *s, const lxb_dom_node_t *n)
 /* Open-addressing pointer-hash set, used to keep the set operators below O(n²)
  * (a CPU-DoS vector at large operand sizes). NULL is the empty sentinel; DOM
  * node pointers are never NULL. Sized once for the expected element count (load
- * factor < 0.5), so it never rehashes. cap == 0 means "not built" — the caller
+ * factor < 0.5), so it never rehashes. cap == 0 means "not built" - the caller
  * then falls back to a linear scan (small operands, or allocation failure). */
 typedef struct {
-    const lxb_dom_node_t **slots;
+    const mkr_raw_node_t **slots;
     size_t                 cap;
 } mkr_ptrset_t;
 
@@ -195,7 +264,7 @@ mkr_ptrset_free(mkr_ptrset_t *set)
 
 /* Add p; returns 1 if newly added, 0 if already present. */
 static int
-mkr_ptrset_add(mkr_ptrset_t *set, const lxb_dom_node_t *p)
+mkr_ptrset_add(mkr_ptrset_t *set, const mkr_raw_node_t *p)
 {
     size_t mask = set->cap - 1;
     size_t j = mkr_ptr_hash(p) & mask;
@@ -208,7 +277,7 @@ mkr_ptrset_add(mkr_ptrset_t *set, const lxb_dom_node_t *p)
 }
 
 static int
-mkr_ptrset_has(const mkr_ptrset_t *set, const lxb_dom_node_t *p)
+mkr_ptrset_has(const mkr_ptrset_t *set, const mkr_raw_node_t *p)
 {
     size_t mask = set->cap - 1;
     size_t j = mkr_ptr_hash(p) & mask;
@@ -230,7 +299,7 @@ static VALUE
 mkr_node_set_op_or(VALUE self, VALUE other)
 {
     mkr_node_set_data_t *s = mkr_node_set_get(self);
-    mkr_node_set_data_t *o = mkr_node_set_get(other);
+    mkr_node_set_data_t *o = mkr_node_set_other(s, other);
     VALUE result = mkr_node_set_new(s->document);
     mkr_node_set_data_t *r = mkr_node_set_get(result);
 
@@ -241,7 +310,7 @@ mkr_node_set_op_or(VALUE self, VALUE other)
     mkr_node_set_data_t *srcs[2] = { s, o };
     for (int k = 0; k < 2; k++) {
         for (size_t i = 0; i < srcs[k]->count; i++) {
-            lxb_dom_node_t *n = srcs[k]->nodes[i];
+            mkr_raw_node_t *n = srcs[k]->nodes[i];
             int fresh = seen.cap ? mkr_ptrset_add(&seen, n)
                                  : !mkr_node_set_member(r, n);
             if (fresh) mkr_node_set_push(result, n);
@@ -256,7 +325,7 @@ static VALUE
 mkr_node_set_op_plus(VALUE self, VALUE other)
 {
     mkr_node_set_data_t *s = mkr_node_set_get(self);
-    mkr_node_set_data_t *o = mkr_node_set_get(other);
+    mkr_node_set_data_t *o = mkr_node_set_other(s, other);
     VALUE result = mkr_node_set_new(s->document);
     for (size_t i = 0; i < s->count; i++) mkr_node_set_push(result, s->nodes[i]);
     for (size_t i = 0; i < o->count; i++) mkr_node_set_push(result, o->nodes[i]);
@@ -269,7 +338,7 @@ static VALUE
 mkr_node_set_op_filter(VALUE self, VALUE other, int keep_if_in_other)
 {
     mkr_node_set_data_t *s = mkr_node_set_get(self);
-    mkr_node_set_data_t *o = mkr_node_set_get(other);
+    mkr_node_set_data_t *o = mkr_node_set_other(s, other);
     VALUE result = mkr_node_set_new(s->document);
     mkr_node_set_data_t *r = mkr_node_set_get(result);
 
@@ -286,7 +355,7 @@ mkr_node_set_op_filter(VALUE self, VALUE other, int keep_if_in_other)
     }
 
     for (size_t i = 0; i < s->count; i++) {
-        lxb_dom_node_t *n = s->nodes[i];
+        mkr_raw_node_t *n = s->nodes[i];
         int in_o = oset.cap ? mkr_ptrset_has(&oset, n) : mkr_node_set_member(o, n);
         if (in_o != keep_if_in_other) continue;
         int fresh = seen.cap ? mkr_ptrset_add(&seen, n) : !mkr_node_set_member(r, n);
@@ -311,15 +380,81 @@ mkr_node_set_op_minus(VALUE self, VALUE other)
     return mkr_node_set_op_filter(self, other, 0);
 }
 
+/* #dup / #clone: a new NodeSet over the same nodes (the nodes are shared - they
+ * are owned by the document arena - but the set itself is independent), like
+ * Nokogiri. Defined here because the allocator is undef'd, so Ruby's default
+ * allocate-then-copy raises; any level/freeze argument is ignored. */
+static VALUE
+mkr_node_set_dup(int argc, VALUE *argv, VALUE self)
+{
+    (void)argc;
+    (void)argv;
+    mkr_node_set_data_t *s = mkr_node_set_get(self);
+    VALUE copy = mkr_node_set_new(s->document);
+    /* Reuse the overflow-checked growth + cap enforcement of mkr_node_set_push;
+     * the source already has no duplicates, so this is a faithful copy. */
+    for (size_t i = 0; i < s->count; i++) {
+        mkr_node_set_push(copy, s->nodes[i]);
+    }
+    return copy;
+}
+
+/* NodeSet.new(document_or_node, list = []) -> NodeSet.
+ * Mirrors Nokogiri: the first argument is the owning Document (or any node, whose
+ * document is taken) that the set pins as a GC keepalive; the optional list seeds
+ * it. Every listed node MUST belong to that document - one from another document
+ * or representation would be re-wrapped under the wrong document/kind, so it is
+ * rejected (fail-closed, preventing the HTML/XML type confusion the set's
+ * representation-opaque storage otherwise relies on document kind to avoid). */
+static VALUE
+mkr_node_set_s_new(int argc, VALUE *argv, VALUE klass)
+{
+    (void)klass;
+    VALUE rb_ctx, rb_list;
+    rb_scan_args(argc, argv, "11", &rb_ctx, &rb_list);
+
+    VALUE rb_doc;
+    if (rb_obj_is_kind_of(rb_ctx, mkr_cDocument)) {
+        rb_doc = rb_ctx;
+    } else if (rb_obj_is_kind_of(rb_ctx, mkr_cNode)) {
+        rb_doc = mkr_node_document(rb_ctx);
+    } else {
+        rb_raise(rb_eTypeError, "expected a Makiri::Document or Node as the first argument");
+    }
+
+    VALUE set = mkr_node_set_new(rb_doc);
+    if (NIL_P(rb_list)) {
+        return set;
+    }
+    VALUE arr = rb_check_array_type(rb_list);
+    if (NIL_P(arr)) {
+        rb_raise(rb_eTypeError, "expected an Array of nodes as the second argument");
+    }
+    for (long i = 0; i < RARRAY_LEN(arr); i++) {
+        VALUE node = RARRAY_AREF(arr, i);
+        if (!rb_obj_is_kind_of(node, mkr_cNode) || mkr_node_document(node) != rb_doc) {
+            rb_raise(rb_eArgError,
+                     "every node must be a Makiri node belonging to the given document");
+        }
+        mkr_node_set_push(set, (mkr_raw_node_t *)mkr_node_raw(node));
+    }
+    return set;
+}
+
 void
 mkr_init_node_set(void)
 {
+    rb_undef_alloc_func(mkr_cNodeSet); /* nodes come only from C; .new seeds via the factory */
+    rb_define_singleton_method(mkr_cNodeSet, "new", mkr_node_set_s_new, -1);
+
     rb_define_method(mkr_cNodeSet, "|", mkr_node_set_op_or,    1);
     rb_define_method(mkr_cNodeSet, "+", mkr_node_set_op_plus,  1);
     rb_define_method(mkr_cNodeSet, "&", mkr_node_set_op_and,   1);
     rb_define_method(mkr_cNodeSet, "-", mkr_node_set_op_minus, 1);
 
     rb_define_method(mkr_cNodeSet, "length", mkr_node_set_length, 0);
-    rb_define_method(mkr_cNodeSet, "[]",     mkr_node_set_aref,   1);
+    rb_define_method(mkr_cNodeSet, "[]",     mkr_node_set_aref,  -1);
     rb_define_method(mkr_cNodeSet, "each",   mkr_node_set_each,   0);
+    rb_define_method(mkr_cNodeSet, "dup",    mkr_node_set_dup,   -1);
+    /* #clone is defined in Ruby (node_set.rb) so it can honour `freeze:`. */
 }