makiri 0.3.0 → 0.4.0

data/ext/makiri/glue/ruby_html_node.c

@@ -729,19 +729,9 @@ mkr_node_line(VALUE self)
 /* ------------------------------------------------------------------ */
 /* identity                                                           */
 /* ------------------------------------------------------------------ */
-
-/* Pointer identity: equal iff both wrap the same lxb_dom_node_t. */
-static VALUE
-mkr_node_equals(VALUE self, VALUE other)
-{
-    if (!rb_obj_is_kind_of(other, mkr_cNode)) {
-        return Qfalse;
-    }
-    /* Identity by pointer, kind-agnostic (an HTML node is simply never equal to an
-     * XML node) - mkr_node_id never dereferences, so comparing across
-     * representations is safe. */
-    return mkr_node_id(self) == mkr_node_id(other) ? Qtrue : Qfalse;
-}
+/* ==/eql?/hash/pointer_id are representation-neutral (mkr_node_id only) and live
+ * in ruby_node.c (the shared node core); this file just binds them below. The
+ * HTML-only <=> (document-order comparison) stays here. */
 
 /* Distance from `n` to the root (a node with no parent). */
 static size_t
@@ -812,25 +802,6 @@ mkr_node_spaceship(VALUE self, VALUE other)
     return Qnil; /* unreachable for a well-formed tree */
 }
 
-/* Nokogiri-compatible identity: the underlying lxb_dom_node_t pointer as an
- * Integer. Stable for the node's lifetime and unique among currently-live
- * nodes; a freed-then-reallocated node may reuse an address (same caveat as
- * Nokogiri::XML::Node#pointer_id). a.pointer_id == b.pointer_id iff a.eql?(b). */
-static VALUE
-mkr_node_pointer_id(VALUE self)
-{
-    return ULL2NUM((unsigned long long)mkr_node_id(self));
-}
-
-/* Stable hash derived from the node pointer, so a == b implies a.hash ==
- * b.hash even across separately-created wrappers. Shares the pointer value
- * with #pointer_id. */
-static VALUE
-mkr_node_hash(VALUE self)
-{
-    return mkr_node_pointer_id(self);
-}
-
 void
 mkr_init_node(void)
 {

data/ext/makiri/glue/ruby_node.c

@@ -104,3 +104,42 @@ mkr_node_document(VALUE rb_node)
     TypedData_Get_Struct(rb_node, mkr_node_data_t, &mkr_node_type, nd);
     return nd->document;
 }
+
+/* ------------------------------------------------------------------ */
+/* identity (representation-neutral)                                  */
+/* ------------------------------------------------------------------ */
+/* These depend only on the kind-agnostic mkr_node_id (which never dereferences a
+ * node), so they are identical for HTML and XML and live here, in the shared
+ * node core, rather than duplicated in each representation's reader file. The
+ * HTML and XML NodeMethods modules both bind their ==/eql?/hash/pointer_id to
+ * these. */
+
+/* Pointer identity: equal iff both wrappers resolve to the same node pointer (an
+ * HTML node is thus never equal to an XML node). */
+VALUE
+mkr_node_equals(VALUE self, VALUE other)
+{
+    if (!rb_obj_is_kind_of(other, mkr_cNode)) {
+        return Qfalse;
+    }
+    return mkr_node_id(self) == mkr_node_id(other) ? Qtrue : Qfalse;
+}
+
+/* Nokogiri-compatible identity: the underlying node pointer as an Integer. Stable
+ * for the node's lifetime and unique among currently-live nodes; a
+ * freed-then-reallocated node may reuse an address (same caveat as
+ * Nokogiri::XML::Node#pointer_id). a.pointer_id == b.pointer_id iff a.eql?(b). */
+VALUE
+mkr_node_pointer_id(VALUE self)
+{
+    return ULL2NUM((unsigned long long)mkr_node_id(self));
+}
+
+/* Stable hash derived from the node pointer, so a == b implies a.hash == b.hash
+ * even across separately-created wrappers. Shares the pointer value with
+ * #pointer_id. */
+VALUE
+mkr_node_hash(VALUE self)
+{
+    return mkr_node_pointer_id(self);
+}

data/ext/makiri/glue/ruby_xml.c

@@ -14,9 +14,38 @@
 #include "glue.h"   /* mkr_wrap_document, mkr_parsed_* (via compat.h) */
 #include "ruby_xpath.h"   /* mkr_xpath_value_to_ruby / mkr_xpath_raise (shared) */
 #include "../xpath/mkr_xpath.h"
+#include "../xpath/mkr_css.h"   /* mkr_css_compile - CSS selectors over XML via the XPath engine */
+#include "../xml/mkr_xml_index.h"   /* element-name index for the //name fast path */
 
 #include <ruby/thread.h>
 
+/* void-typed adapters so the engine's representation-neutral name-index hooks
+ * can reach the XML element-name index (mkr_xml_index.c) without the engine
+ * knowing its concrete types. */
+static void *
+mkr_xml_name_index_get_v(void *owner)
+{
+    return mkr_xml_name_index_get((mkr_xml_doc_t *)owner);
+}
+
+static void *const *
+mkr_xml_name_index_lookup_v(const void *idx, const char *local, size_t local_len,
+                            const char *ns_uri, size_t ns_uri_len, size_t *count)
+{
+    return (void *const *)mkr_xml_name_index_lookup(
+        (const mkr_xml_name_index_t *)idx, local, local_len, ns_uri, ns_uri_len, count);
+}
+
+/* Install the document's element-name index hooks on +ctx+ (the engine lazily
+ * builds it only when a document-rooted descendant name test runs). */
+static void
+mkr_xml_install_name_index(mkr_xpath_context_t *ctx, mkr_xml_doc_t *xdoc)
+{
+    mkr_xpath_context_set_name_index(ctx, (void *)xdoc,
+                                     mkr_xml_name_index_get_v,
+                                     mkr_xml_name_index_lookup_v);
+}
+
 /* ---- GVL-released parse ---- */
 typedef struct {
     const char      *src;
@@ -93,23 +122,26 @@ mkr_xml_s_parse(int argc, VALUE *argv, VALUE self)
      * document is not materialised twice for a doomed parse. */
     VALUE decoded = mkr_xml_decode_input(rb_String(rb_source), budget);
 
-    /* Build an empty XML handle and wrap it first (doc == NULL) so a failure
-     * mid-parse frees cleanly via GC (mkr_parsed_destroy -> the XML branch ->
-     * mkr_xml_doc_destroy(NULL), a no-op). */
+    /* Copy the decoded bytes into a private C buffer up front - BEFORE allocating
+     * any Ruby object (the wrap below) - so there is NO GC point between obtaining
+     * +decoded+ and copying it, and the parse can then run with the GVL released
+     * without racing GC/compaction on the String's backing store. */
+    mkr_owned_bytes_t source = {0};
+    if (mkr_ruby_copy_bytes(decoded, &source) != 0) {
+        rb_raise(mkr_eError, "out of memory copying XML source");
+    }
+
+    /* Build an empty XML handle and wrap it (doc == NULL) so a failure mid-parse
+     * frees cleanly via GC (mkr_parsed_destroy -> the XML branch ->
+     * mkr_xml_doc_destroy(NULL), a no-op). The source is already copied, so this
+     * Ruby allocation cannot disturb it. */
     mkr_parsed_t *parsed = mkr_parsed_new_xml(NULL);
     if (parsed == NULL) {
+        mkr_owned_bytes_clear(&source);
         rb_raise(mkr_eError, "out of memory allocating XML document");
     }
     VALUE obj = mkr_wrap_document(parsed); /* GC owns +parsed+ from here */
 
-    /* Copy the decoded bytes so the parse can run with the GVL released without
-     * racing GC/compaction on the String's backing store. */
-    mkr_owned_bytes_t source = {0};
-    if (mkr_ruby_copy_bytes(decoded, &source) != 0) {
-        rb_raise(mkr_eError, "out of memory copying XML source");
-    }
-    RB_GC_GUARD(decoded);
-
     mkr_xml_parse_nogvl_t args = { source.ptr, source.len, limits, NULL, MKR_XML_OK };
     rb_thread_call_without_gvl(mkr_xml_parse_nogvl, &args, NULL, NULL);
     mkr_owned_bytes_clear(&source);
@@ -124,7 +156,6 @@ mkr_xml_s_parse(int argc, VALUE *argv, VALUE self)
         }
     }
     mkr_parsed_set_xml_doc(parsed, args.result);
-    RB_GC_GUARD(obj);
     return obj;
 }
 
@@ -182,7 +213,6 @@ mkr_xml_register_query_namespaces(mkr_xpath_context_t *ctx, VALUE rb_ns)
             rb_raise(mkr_eError, "failed to register namespace");
         }
     }
-    RB_GC_GUARD(keys);
 }
 
 /* Makiri::XML::{Document,*}#xpath(expr, namespaces = nil) / #at_xpath(...):
@@ -211,6 +241,7 @@ mkr_xml_doc_xpath_run(VALUE self, VALUE rb_expr, VALUE rb_ns, int first_only)
         rb_raise(mkr_eError, "failed to allocate XPath context");
     }
     mkr_xpath_set_engine_kind(ctx, 1);
+    mkr_xml_install_name_index(ctx, xdoc);
     mkr_xml_register_query_namespaces(ctx, rb_ns); /* frees ctx + raises on error */
 
     /* Mint the borrowed expression view AFTER namespace registration: that step
@@ -260,6 +291,153 @@ mkr_xml_doc_at_xpath(int argc, VALUE *argv, VALUE self)
     return mkr_xml_doc_xpath_run(self, expr, ns, 1);
 }
 
+/* ---- CSS selectors over XML (lowered to the native XPath engine) ----
+ *
+ * Makiri::XML CSS support compiles a selector to the engine's AST (mkr_css.c)
+ * and runs it through the SAME evaluator as #xpath, so case-sensitivity,
+ * namespaces, budgets and document order are identical. The Ruby wrappers
+ * (lib/makiri/xml/node_methods.rb) collect the document's namespaces and pass a
+ * normalised {prefix => uri} hash; the default namespace, if any, arrives under
+ * the synthetic prefix "xmlns" (Nokogiri's convention), and a bare type selector
+ * binds to it. These are the private `_css` / `_at_css` / `_css_matches?`
+ * primitives those wrappers call. */
+
+/* The synthetic default-namespace prefix, present iff the (already
+ * prefix-normalised) namespace hash carries an "xmlns" key. */
+static const char *
+mkr_css_default_prefix(VALUE rb_ns)
+{
+    if (RB_TYPE_P(rb_ns, T_HASH)
+        && !NIL_P(rb_hash_aref(rb_ns, rb_str_new_cstr(MKR_CSS_DEFAULT_NS_PREFIX)))) {
+        return MKR_CSS_DEFAULT_NS_PREFIX;
+    }
+    return NULL;
+}
+
+/* Compile +rb_selector+ to an AST under +ctx+ (its namespaces already
+ * registered). On a CSS syntax error raises Makiri::CSS::SyntaxError; on any
+ * other engine error frees ctx and raises via the shared raiser. Returns the AST
+ * (caller frees with mkr_node_free). */
+static mkr_node_t *
+mkr_css_compile_or_raise(mkr_xpath_context_t *ctx, VALUE rb_selector, VALUE rb_ns)
+{
+    mkr_css_ns_t cns = { mkr_css_default_prefix(rb_ns) };
+    mkr_ruby_borrowed_text_t sv = mkr_ruby_verified_text(rb_selector, "CSS selector");
+    mkr_xpath_error_t error = {0};
+    mkr_xpath_limits_t *limits = mkr_ctx_limits(ctx);
+    limits->ast_nodes = 0;
+    mkr_node_t *ast = mkr_css_compile(mkr_verified_text_from_view(sv), &cns, limits, &error);
+    RB_GC_GUARD(sv.value);
+    if (ast == NULL) {
+        int syntax = (error.status == MKR_XPATH_ERR_SYNTAX);
+        mkr_xpath_context_free(ctx);
+        if (syntax) {
+            VALUE msg = error.message ? rb_utf8_str_new_cstr(error.message)
+                                      : rb_str_new_cstr("invalid CSS selector");
+            mkr_xpath_error_clear(&error);
+            rb_raise(mkr_eCSSSyntaxError, "%" PRIsVALUE, msg);
+        }
+        mkr_xpath_raise(&error); /* frees error.message, never returns */
+    }
+    return ast;
+}
+
+static VALUE
+mkr_xml_doc_css_run(VALUE self, VALUE rb_selector, VALUE rb_ns, int first_only)
+{
+    VALUE document = Qnil;
+    mkr_xml_node_t *context = mkr_xml_query_context(self, &document);
+    if (context == NULL) {
+        return first_only ? Qnil : mkr_node_set_new(document);
+    }
+    mkr_xml_doc_t *xdoc = mkr_parsed_xml_doc(mkr_doc_parsed(document));
+
+    mkr_xpath_context_t *ctx =
+        mkr_xpath_context_new((void *)xdoc->doc_node, (void *)context);
+    if (ctx == NULL) {
+        rb_raise(mkr_eError, "failed to allocate XPath context");
+    }
+    mkr_xpath_set_engine_kind(ctx, 1);
+    mkr_xml_install_name_index(ctx, xdoc);
+    mkr_xml_register_query_namespaces(ctx, rb_ns); /* frees ctx + raises on error */
+
+    mkr_node_t *ast = mkr_css_compile_or_raise(ctx, rb_selector, rb_ns); /* frees ctx + raises on error */
+
+    mkr_xpath_value_t value = {0};
+    mkr_xpath_error_t error = {0};
+    int rc = first_only ? mkr_xpath_eval_compiled_first(ctx, ast, &value, &error)
+                        : mkr_xpath_eval_compiled(ctx, ast, &value, &error);
+    mkr_node_free(ast);
+    if (rc != 0) {
+        mkr_xpath_context_free(ctx);
+        mkr_xpath_raise(&error);
+    }
+    VALUE result = mkr_xpath_value_to_ruby(&value, document); /* converts AND clears value */
+    mkr_xpath_context_free(ctx);
+
+    if (first_only && rb_obj_is_kind_of(result, mkr_cNodeSet)) {
+        return rb_funcall(result, rb_intern("first"), 0);
+    }
+    return result;
+}
+
+static VALUE
+mkr_xml_node_css(VALUE self, VALUE selector, VALUE ns)
+{
+    return mkr_xml_doc_css_run(self, selector, ns, 0);
+}
+
+static VALUE
+mkr_xml_node_at_css(VALUE self, VALUE selector, VALUE ns)
+{
+    return mkr_xml_doc_css_run(self, selector, ns, 1);
+}
+
+/* #matches?(selector): does THIS node match the selector? Evaluated by selecting
+ * every matching node in the whole document (context = the document node, so the
+ * descendant-rooted selector scans the entire tree) and testing membership by
+ * node identity - the full-combinator-correct semantics. */
+static VALUE
+mkr_xml_node_css_matches(VALUE self, VALUE selector, VALUE ns)
+{
+    VALUE document = Qnil;
+    mkr_xml_node_t *node = mkr_xml_query_context(self, &document);
+    if (node == NULL) {
+        return Qfalse;
+    }
+    mkr_xml_doc_t *xdoc = mkr_parsed_xml_doc(mkr_doc_parsed(document));
+
+    mkr_xpath_context_t *ctx =
+        mkr_xpath_context_new((void *)xdoc->doc_node, (void *)xdoc->doc_node);
+    if (ctx == NULL) {
+        rb_raise(mkr_eError, "failed to allocate XPath context");
+    }
+    mkr_xpath_set_engine_kind(ctx, 1);
+    mkr_xml_install_name_index(ctx, xdoc);
+    mkr_xml_register_query_namespaces(ctx, ns); /* frees ctx + raises on error */
+
+    mkr_node_t *ast = mkr_css_compile_or_raise(ctx, selector, ns); /* frees ctx + raises on error */
+
+    mkr_xpath_value_t value = {0};
+    mkr_xpath_error_t error = {0};
+    int rc = mkr_xpath_eval_compiled(ctx, ast, &value, &error);
+    mkr_node_free(ast);
+    if (rc != 0) {
+        mkr_xpath_context_free(ctx);
+        mkr_xpath_raise(&error);
+    }
+
+    int found = 0;
+    if (value.type == MKR_XPATH_TYPE_NODESET) {
+        for (size_t i = 0; i < value.u.nodeset.count; i++) {
+            if (value.u.nodeset.nodes[i] == (void *)node) { found = 1; break; }
+        }
+    }
+    mkr_xpath_value_clear(&value);
+    mkr_xpath_context_free(ctx);
+    return found ? Qtrue : Qfalse;
+}
+
 /* The document's root element. */
 static VALUE
 mkr_xml_doc_root(VALUE self)
@@ -311,7 +489,6 @@ mkr_xml_fragment_into(mkr_xml_doc_t *xdoc, VALUE rb_source, int inherit_doc_ns)
     if (mkr_ruby_copy_bytes(decoded, &src) != 0) {
         rb_raise(mkr_eError, "out of memory copying XML fragment source");
     }
-    RB_GC_GUARD(decoded);
 
     mkr_xml_status_t st = MKR_XML_OK;
     mkr_xml_node_t *frag = mkr_xml_parse_fragment(xdoc, src.ptr, src.len, inherit_doc_ns, &st);
@@ -369,7 +546,6 @@ mkr_xml_fragment_s_parse(VALUE klass, VALUE rb_source)
     mkr_xml_doc_t *xdoc = mkr_parsed_xml_doc(mkr_doc_parsed(doc_obj));
     mkr_xml_node_t *frag = mkr_xml_fragment_into(xdoc, rb_source, 0);
     VALUE result = mkr_wrap_xml_node(frag, doc_obj);
-    RB_GC_GUARD(doc_obj);
     return result;
 }
 
@@ -386,7 +562,6 @@ mkr_xml_doc_fragment(VALUE self, VALUE rb_source)
     }
     mkr_xml_node_t *frag = mkr_xml_fragment_into(xdoc, rb_source, 1);
     VALUE result = mkr_wrap_xml_node(frag, self);
-    RB_GC_GUARD(self);
     return result;
 }
 
@@ -413,6 +588,13 @@ mkr_init_xml(void)
     rb_define_method(mkr_mXmlNodeMethods, "xpath",    mkr_xml_doc_xpath,    -1);
     rb_define_method(mkr_mXmlNodeMethods, "at_xpath", mkr_xml_doc_at_xpath, -1);
 
+    /* CSS selectors over XML: private primitives called by the Ruby #css /
+     * #at_css / #matches? wrappers (which collect the document namespaces). The
+     * selector is lowered to the native XPath engine (mkr_css.c). */
+    rb_define_private_method(mkr_mXmlNodeMethods, "_css",        mkr_xml_node_css,         2);
+    rb_define_private_method(mkr_mXmlNodeMethods, "_at_css",     mkr_xml_node_at_css,      2);
+    rb_define_private_method(mkr_mXmlNodeMethods, "_css_matches", mkr_xml_node_css_matches, 2);
+
     /* The native XML parser, exposed as XML::Document.parse, mirroring HTML
      * (HTML::Document.parse). The Makiri::XML(source) convenience delegates to it
      * in Ruby (lib/makiri.rb), as Makiri.HTML does for HTML::Document.parse. */

data/ext/makiri/glue/ruby_xml_node.c

@@ -13,6 +13,7 @@
 #include "glue.h"
 #include "../xml/mkr_xml_node.h"
 #include "../xml/mkr_xml_mutate.h"
+#include "../xml/mkr_xml_index.h"   /* element-name index invalidation on mutation */
 #include "../core/mkr_core.h"   /* mkr_buf */
 
 #include <ruby/encoding.h>     /* rb_to_encoding / rb_str_encode (output encoding) */
@@ -339,7 +340,7 @@ mkr_xml_node_aref(VALUE self, VALUE rb_name)
     mkr_ruby_borrowed_text_t nv = mkr_ruby_verified_text(rb_name, "attribute name");
     VALUE out = Qnil;
     for (mkr_xml_node_t *a = n->attrs; a != NULL; a = a->next) {
-        if (a->qname_len == nv.len && memcmp(a->qname, nv.ptr, nv.len) == 0) {
+        if (mkr_bytes_eq(a->qname, a->qname_len, nv.ptr, nv.len)) {
             out = rb_utf8_str_new(a->value ? a->value : "", (long)a->value_len);
             break;
         }
@@ -565,15 +566,25 @@ mkr_xml_node_to_xml(int argc, VALUE *argv, VALUE self)
     int rc = 0;
 
     if (rb_obj_is_kind_of(self, mkr_cXmlDocument)) {
-        static const char decl_a[] = "<?xml version=\"1.0\" encoding=\"";
-        static const char decl_b[] = "\"?>\n";
-        VALUE name = NIL_P(enc_name) ? rb_utf8_str_new_cstr("UTF-8") : enc_name;
-        mkr_ruby_borrowed_bytes_t nv = mkr_ruby_bytes_view(name);
         mkr_xml_doc_t *xdoc = mkr_parsed_xml_doc(mkr_doc_parsed(self));
-        rc = (mkr_buf_append(&buf, decl_a, sizeof(decl_a) - 1) == MKR_OK) ? 0 : -1;
-        if (rc == 0) rc = (mkr_buf_append(&buf, nv.ptr, nv.len) == MKR_OK) ? 0 : -1;
-        if (rc == 0) rc = (mkr_buf_append(&buf, decl_b, sizeof(decl_b) - 1) == MKR_OK) ? 0 : -1;
-        RB_GC_GUARD(nv.value);
+        /* Emit the encoding pseudo-attribute only when an explicit encoding: was
+         * requested or the parsed source declared one; otherwise a built or
+         * declaration-less document round-trips to a bare `<?xml version="1.0"?>`,
+         * matching Nokogiri (the output is UTF-8 either way). */
+        int emit_enc = !NIL_P(enc_name) || (xdoc != NULL && xdoc->has_encoding_decl);
+        if (emit_enc) {
+            static const char decl_a[] = "<?xml version=\"1.0\" encoding=\"";
+            static const char decl_b[] = "\"?>\n";
+            VALUE name = NIL_P(enc_name) ? rb_utf8_str_new_cstr("UTF-8") : enc_name;
+            mkr_ruby_borrowed_bytes_t nv = mkr_ruby_bytes_view(name);
+            rc = (mkr_buf_append(&buf, decl_a, sizeof(decl_a) - 1) == MKR_OK) ? 0 : -1;
+            if (rc == 0) rc = (mkr_buf_append(&buf, nv.ptr, nv.len) == MKR_OK) ? 0 : -1;
+            if (rc == 0) rc = (mkr_buf_append(&buf, decl_b, sizeof(decl_b) - 1) == MKR_OK) ? 0 : -1;
+            RB_GC_GUARD(nv.value);
+        } else {
+            static const char decl[] = "<?xml version=\"1.0\"?>\n";
+            rc = (mkr_buf_append(&buf, decl, sizeof(decl) - 1) == MKR_OK) ? 0 : -1;
+        }
         if (rc == 0 && xdoc != NULL && xdoc->doctype != NULL) {
             rc = mkr_xser_doctype(&buf, xdoc->doctype);
             if (rc == 0) rc = (mkr_buf_append(&buf, "\n", 1) == MKR_OK) ? 0 : -1;
@@ -678,8 +689,8 @@ mkr_c14n_nearest(const mkr_xml_node_t *node, const char *prefix, uint32_t plen,
         if (e->type != MKR_XML_NODE_TYPE_ELEMENT) continue;
         for (mkr_xml_node_t *a = e->attrs; a != NULL; a = a->next) {
             const char *p, *u; uint32_t pl, ul;
-            if (mkr_xml_node_xmlns_decl(a, &p, &pl, &u, &ul) && pl == plen
-                && (pl == 0 || memcmp(p, prefix, pl) == 0)) {
+            if (mkr_xml_node_xmlns_decl(a, &p, &pl, &u, &ul)
+                && mkr_bytes_eq(p, pl, prefix, plen)) {
                 *uri = u; *ulen = ul; return 1;
             }
         }
@@ -691,7 +702,7 @@ static int
 mkr_c14n_has_prefix(const mkr_c14n_ns_t *arr, size_t n, const char *p, uint32_t pl)
 {
     for (size_t i = 0; i < n; i++)
-        if (arr[i].plen == pl && (pl == 0 || memcmp(arr[i].prefix, p, pl) == 0)) return 1;
+        if (mkr_bytes_eq(arr[i].prefix, arr[i].plen, p, pl)) return 1;
     return 0;
 }
 
@@ -724,7 +735,7 @@ mkr_c14n_namespaces(const mkr_xml_node_t *n, int is_apex, mkr_c14n_ns_t **out)
             for (mkr_xml_node_t *a = e->attrs; a != NULL; a = a->next) {
                 const char *p, *u; uint32_t pl, ul;
                 if (!mkr_xml_node_xmlns_decl(a, &p, &pl, &u, &ul)) continue;
-                if (pl == 3 && memcmp(p, "xml", 3) == 0) continue;             /* implicit xml: */
+                if (mkr_bytes_eq(p, pl, "xml", 3)) continue;                   /* implicit xml: */
                 if (is_apex) {
                     if (pl == 0) {                /* default: nearest decl wins */
                         if (default_seen) continue;
@@ -736,7 +747,7 @@ mkr_c14n_namespaces(const mkr_xml_node_t *n, int is_apex, mkr_c14n_ns_t **out)
                 } else {                          /* descendant: only changes to the binding */
                     const char *au; uint32_t aul;
                     int above = mkr_c14n_nearest(e->parent, p, pl, &au, &aul);
-                    if (above && aul == ul && (ul == 0 || memcmp(au, u, ul) == 0)) continue; /* superfluous */
+                    if (above && mkr_bytes_eq(au, aul, u, ul)) continue; /* superfluous */
                     if (pl == 0 && ul == 0 && !(above && aul > 0)) continue; /* xmlns="" only undeclares */
                 }
                 arr[cnt].prefix = p; arr[cnt].plen = pl;
@@ -884,27 +895,13 @@ mkr_xml_node_canonicalize(int argc, VALUE *argv, VALUE self)
     return str;
 }
 
-/* ---- fail-closed guards for the unsupported query / serialization surface ----
+/* ---- fail-closed guard for the unsupported serialization surface ----
  *
- * Makiri::XML is a strict, read-only reader (§7.5 / §12). Two HTML-node
- * conveniences would silently misbehave on XML and are turned into explicit
- * NotImplementedError instead of a wrong result:
- *   - CSS selectors: Lexbor's lxb_selectors lower-cases names, which destroys
- *     XML's case- and namespace-sensitive matching - use #xpath.
- *   - HTML serialization (to_html/inner_html/outer_html): emitting
- *     HTML-serialized markup for an XML document would be wrong (escaping /
- *     CDATA / void elements differ). Use #to_xml. */
-static VALUE
-mkr_xml_node_no_css(int argc, VALUE *argv, VALUE self)
-{
-    (void)argc; (void)argv; (void)self;
-    rb_raise(rb_eNotImpError,
-             "Makiri::XML does not support CSS selectors; use #xpath. "
-             "(CSS cannot preserve XML element-name case or namespaces.) "
-             "Default-namespace documents (RSS/Atom) need a registered prefix, "
-             "e.g. doc.xpath(\"//a:entry\", \"a\" => \"http://www.w3.org/2005/Atom\").");
-}
-
+ * HTML serialization (to_html/inner_html/outer_html) would silently misbehave on
+ * XML (escaping / CDATA / void elements differ), so it is an explicit
+ * NotImplementedError rather than a wrong result. Use #to_xml. (CSS selectors,
+ * once unsupported here, are now lowered to the native XPath engine - see
+ * ruby_xml.c.) */
 static VALUE
 mkr_xml_node_no_serialize(int argc, VALUE *argv, VALUE self)
 {
@@ -917,23 +914,10 @@ mkr_xml_node_no_serialize(int argc, VALUE *argv, VALUE self)
 /* ---- node identity (== / eql? / hash / pointer_id) ----
  *
  * XML nodes share the mkr_node_data_t typed-data with HTML nodes, so the
- * underlying node pointer (mkr_node_id, representation-agnostic) IS the
- * identity. Without these, two wrappers for the same XML node compared unequal
- * (Object identity), which broke #path, NodeSet/Set dedup, and Hash keys.
- * Same contract as the HTML nodes (ruby_node.c): a.pointer_id == b.pointer_id
- * iff a.eql?(b). */
-static VALUE
-mkr_xml_node_pointer_id(VALUE self)
-{
-    return ULL2NUM((unsigned long long)mkr_node_id(self));
-}
-
-static VALUE
-mkr_xml_node_equals(VALUE self, VALUE other)
-{
-    if (!rb_obj_is_kind_of(other, mkr_cNode)) return Qfalse;
-    return mkr_node_id(self) == mkr_node_id(other) ? Qtrue : Qfalse;
-}
+ * underlying node pointer (mkr_node_id, representation-agnostic) IS the identity.
+ * The implementations are therefore representation-neutral and live once in
+ * ruby_node.c (mkr_node_equals / mkr_node_hash / mkr_node_pointer_id); the XML
+ * NodeMethods module just binds to them below, exactly as the HTML module does. */
 
 /* ---- mutation (Phase 1: in-place edits) ----------------------------------
  *
@@ -991,6 +975,10 @@ static mkr_xml_node_t *
 mkr_xml_node_unwrap_mutable(VALUE self)
 {
     rb_check_frozen(self);
+    /* Single mutation choke point (every mutator calls this): drop the cached
+     * element-name index so the next query rebuilds it. Same discipline as the
+     * HTML attr/text indices, in one place that cannot be forgotten. */
+    mkr_xml_name_index_invalidate(mkr_xml_node_xdoc(self));
     return mkr_xml_node_unwrap(self);
 }
 
@@ -1359,10 +1347,10 @@ mkr_init_xml_node(void)
 
     /* Node identity by underlying pointer, so #path / NodeSet dedup / Set / Hash
      * work (the same contract HTML nodes have). */
-    rb_define_method(mkr_mXmlNodeMethods, "==",         mkr_xml_node_equals, 1);
-    rb_define_method(mkr_mXmlNodeMethods, "eql?",       mkr_xml_node_equals, 1);
-    rb_define_method(mkr_mXmlNodeMethods, "hash",       mkr_xml_node_pointer_id, 0);
-    rb_define_method(mkr_mXmlNodeMethods, "pointer_id", mkr_xml_node_pointer_id, 0);
+    rb_define_method(mkr_mXmlNodeMethods, "==",         mkr_node_equals, 1);
+    rb_define_method(mkr_mXmlNodeMethods, "eql?",       mkr_node_equals, 1);
+    rb_define_method(mkr_mXmlNodeMethods, "hash",       mkr_node_hash, 0);
+    rb_define_method(mkr_mXmlNodeMethods, "pointer_id", mkr_node_pointer_id, 0);
 
     /* XML serialization: #to_xml / #to_s re-emit the subtree (a Document also
      * emits the declaration + DOCTYPE). Also defined on XML::Document below. */
@@ -1370,10 +1358,9 @@ mkr_init_xml_node(void)
     rb_define_method(mkr_mXmlNodeMethods, "to_s",       mkr_xml_node_to_xml, -1);
     rb_define_method(mkr_mXmlNodeMethods, "canonicalize", mkr_xml_node_canonicalize, -1);
 
-    /* Fail-closed: CSS + HTML serialization are unsupported on XML; raise rather
-     * than return a wrong result (these shadow nothing on XML nodes otherwise). */
-    rb_define_method(mkr_mXmlNodeMethods, "css",        mkr_xml_node_no_css, -1);
-    rb_define_method(mkr_mXmlNodeMethods, "at_css",     mkr_xml_node_no_css, -1);
+    /* CSS selectors (#css / #at_css / #matches?) are supported on XML via the
+     * native XPath engine - registered in ruby_xml.c. Fail-closed: HTML
+     * serialization is unsupported on XML; raise rather than emit wrong markup. */
     rb_define_method(mkr_mXmlNodeMethods, "to_html",    mkr_xml_node_no_serialize, -1);
     rb_define_method(mkr_mXmlNodeMethods, "inner_html", mkr_xml_node_no_serialize, -1);
     rb_define_method(mkr_mXmlNodeMethods, "outer_html", mkr_xml_node_no_serialize, -1);

data/ext/makiri/glue/ruby_xpath.c

@@ -396,7 +396,6 @@ mkr_ruby_to_out(mkr_xpath_context_t *ctx, VALUE document, VALUE r, mkr_val_t *ou
         if (mkr_val_set_borrowed_text_copy(out, mkr_borrowed_text(vv.ptr, vv.len),
                                            NULL, NULL) != 0) {
             snprintf(errbuf, errlen, "out of memory converting handler result");
-            RB_GC_GUARD(vv.value);
             return -1;
         }
         RB_GC_GUARD(vv.value);
@@ -642,10 +641,11 @@ static VALUE
 mkr_xpath_ctx_register_variable(VALUE self, VALUE rb_name, VALUE rb_value)
 {
     mkr_xpath_ctx_data_t *d = mkr_xpath_ctx_unwrap(self);
-    mkr_ruby_borrowed_text_t nv = mkr_ruby_verified_text(rb_name, "variable name");
-    /* The value gets the stricter engine-string check (adds the byte cap on top
-     * of no-NUL / valid-UTF-8). */
+    /* Coerce the value FIRST (rb_obj_as_string allocates = a GC point), so no
+     * borrowed name bytes are held across it. The value gets the stricter
+     * engine-string check (adds the byte cap on top of no-NUL / valid-UTF-8). */
     VALUE value = rb_obj_as_string(rb_value);
+    mkr_ruby_borrowed_text_t nv = mkr_ruby_verified_text(rb_name, "variable name");
     mkr_ruby_borrowed_text_t vv;
     const char *bad =
         mkr_ruby_try_verified_text(value, mkr_ctx_limits(d->ctx)->max_string_bytes, &vv);

data/ext/makiri/lexbor_compat/source_loc.c

@@ -8,7 +8,6 @@
 
 #include <stdint.h>
 #include <stdlib.h>
-#include <string.h>   /* memchr */
 
 /*
  * Source location tracking. Lexbor does not record where in the input a node
@@ -39,18 +38,15 @@ typedef struct {
 void *
 mkr_lines_build(const lxb_char_t *src, size_t len)
 {
-    if (src == NULL) {
-        len = 0;
-    }
-
-    const lxb_char_t *const end = src + len;
+    /* mkr_span normalizes src == NULL to the empty span, so the absent-input
+     * case (no newlines, one line) flows through with no special guard. */
 
-    /* One pass to count newlines (vectorised memchr), so the array is sized
-     * once. */
-    size_t nl = 0;
-    for (const lxb_char_t *p = src;
-         (p = memchr(p, '\n', (size_t)(end - p))) != NULL;
-         p++) {
+    /* One pass to count newlines (mkr_span_find is still one memchr per line,
+     * inside the audited core), so the array is sized once. */
+    mkr_span_t s = mkr_span((const char *)src, len);
+    size_t nl = 0, at;
+    while (mkr_span_find(&s, '\n', &at)) {
+        mkr_span_skip(&s, at + 1); /* past the '\n' (find proved it exists) */
         nl++;
     }
 
@@ -65,12 +61,14 @@ mkr_lines_build(const lxb_char_t *src, size_t len)
         return NULL;
     }
 
+    mkr_span_t f = mkr_span((const char *)src, len);
+    const char *start = mkr_span_mark(&f);
     size_t line = 0;
     t->starts[line++] = 0;
-    for (const lxb_char_t *p = src;
-         (p = memchr(p, '\n', (size_t)(end - p))) != NULL;
-         p++) {
-        t->starts[line++] = (size_t)(p - src) + 1;
+    while (mkr_span_find(&f, '\n', &at)) {
+        mkr_span_skip(&f, at + 1);
+        /* offset just past the '\n' = next line's start */
+        t->starts[line++] = mkr_span_since(&f, start);
     }
     return t;
 }