makiri 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d7f8de6bbef8fc2fbb17df06bbc9e0fcea04d04ddab17cfa25cb723b5af4c17
-  data.tar.gz: e3de39e5c405d058807c2a9d4fd00a9c7a3d7b876037b0e152c4d80d162f59ec
+  metadata.gz: f88832bca79aadf7ea686b37739a5b600d9ff4a2075f28e9d59a885a66afab80
+  data.tar.gz: 6f835ef9f2bee6318e9ef5ff179dac48b7e99b2f019fb85f86c67eb94fced1e9
 SHA512:
-  metadata.gz: 309d9b79ac58fdd1bd68ccd1f817efe8ce5de3bc4d8e21555babca1490a088b0694e43f4fd36f524b5591c5a2b9c10ff18e4c8a7457483f091d31b73a4e34e73
-  data.tar.gz: cf184ca85e1c985b8dbbabdbd3684ee5b0d9cbffb874761189621f08141f3196c352cc1e36882b4860225cbefb471d2fc13ad1886de7a1fabffda3e0602952c6
+  metadata.gz: 4171815b57b086979c4638b44cd9316562e7293b16c40302a62e78b7a93c30f0a1e0dd4f09764574fe20c5b6e948699dee64dad6d45136e582da22b4ac5fc74d
+  data.tar.gz: ee5dda37c9dc8722d7313b96981312b0d1b1599dde764eeb108ba8397655586cfd793d6ce1a3f9473ae0cfc0e542d6e50f87c93dc355d9237432de00d088bb29

data/.github/workflows/release.yml

@@ -18,7 +18,7 @@ on:
   workflow_dispatch:
     inputs:
       publish_to_rubygems:
-        description: "Push the built gems to RubyGems (requires the RUBYGEMS_API_KEY secret)"
+        description: "Push the built gems to RubyGems (via Trusted Publishing / OIDC)"
         type: boolean
         default: false
 
@@ -197,12 +197,19 @@ jobs:
           gh release upload "${GITHUB_REF_NAME}" dist/*.gem --repo "${GITHUB_REPOSITORY}" --clobber
 
   # --- optional: publish to RubyGems (manual, opt-in, never on a tag push) ----
+  # Auth is RubyGems Trusted Publishing (OIDC): no stored API key, short-lived
+  # token, MFA-compatible. Configure a matching Trusted Publisher on RubyGems.org
+  # for this gem: owner=takahashim, repo=makiri, workflow=release.yml, and set its
+  # Environment to "rubygems" (matching `environment:` below).
   publish:
     name: Publish to RubyGems
     needs: [source-gem, native-gem]
     if: github.event_name == 'workflow_dispatch' && inputs.publish_to_rubygems
     runs-on: ubuntu-latest
-    environment: rubygems   # add a protection rule here for a manual approval gate
+    environment: rubygems   # add a Required-reviewers protection rule for an approval gate
+    permissions:
+      contents: read
+      id-token: write       # OIDC identity token for Trusted Publishing
     steps:
       - uses: ruby/setup-ruby@v1
         with:
@@ -212,11 +219,10 @@ jobs:
           pattern: gem-*
           merge-multiple: true
           path: dist
+      - name: Configure RubyGems credentials (OIDC trusted publishing)
+        uses: rubygems/configure-rubygems-credentials@762a4b77c3300434bb57c7ce80b20e36231927aa # v2.0.0
       - name: gem push
-        env:
-          GEM_HOST_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}
         run: |
-          test -n "$GEM_HOST_API_KEY" || { echo "RUBYGEMS_API_KEY secret is not set"; exit 1; }
           for g in dist/*.gem; do
             echo "Pushing $g"
             gem push "$g"

data/CHANGELOG.md

@@ -7,6 +7,69 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-06-04
+
+### Added
+
+* `Element#tag_name` (DOM `tagName`) — the qualified name uppercased for an
+  HTML element in an HTML document (`"DIV"`), keeping the original case for
+  SVG/MathML; `nil` for non-elements. Complements `#name`, which stays the
+  lowercase qualified name.
+* `ProcessingInstruction#target` (DOM `target`) — a PI's target name; `nil` for
+  other node kinds. Its data is read via `#content`/`#text`.
+* `Document#create_processing_instruction(target, data)` (DOM
+  `createProcessingInstruction`) and `Document#create_document_fragment` (DOM
+  `createDocumentFragment`, an empty fragment to build up programmatically —
+  unlike `#fragment` / `DocumentFragment.parse`, which parse HTML). Both produce
+  a detached node owned by the document; PI creation fails closed when the data
+  contains the `?>` terminator (matching the DOM constraint). (DOM
+  `createCDATASection` is intentionally not provided: per WHATWG DOM it throws on
+  an HTML document, which is the only kind Makiri produces.)
+* `Node#{namespace_uri, prefix, local_name}` — the WHATWG DOM per-node
+  namespace accessors on `Element` and `Attribute` (`nil` on other node kinds).
+  `namespace_uri` resolves an element's namespace from its node (so an HTML
+  element is the XHTML namespace `http://www.w3.org/1999/xhtml`, not `nil` — the
+  DOM-faithful value browsers and `namespace-uri()` return; SVG/MathML get their
+  own URI), and agrees byte-for-byte with the `namespace-uri()` XPath function.
+  For attributes it is `nil` unless prefixed, where it returns the parser-assigned
+  foreign-content namespace (`xlink`/`xml`/`xmlns`). `prefix` is the prefix
+  segment of the qualified name (`nil` for the usual unprefixed HTML5 case), and
+  `local_name` is the name without that prefix. Previously a node's namespace was
+  reachable only through XPath (`namespace-uri()`/`local-name()`).
+* `Node#clone_node(deep = false)` — a copy of the node, owned by the same
+  document and detached from any parent (the DOM `cloneNode`, whose `deep`
+  defaults to `false` — a missing/`nil`/`false` argument is a shallow clone; a
+  truthy one copies the subtree). Built on the same `import_node` +
+  `<template>`-content fixup the fragment parser uses, so a deep-cloned
+  `<template>` keeps its contents. Fails closed: a failed import raises rather
+  than returning a partial node.
+* `Document#import_node(node, deep = false)` — a copy of `node` owned by the
+  receiver document (the DOM `importNode`, whose `deep` likewise defaults to
+  `false`). Unlike `Node#clone_node`, the copy is owned by the target rather
+  than the node's own document, so it is the way to bring a node across
+  documents (Makiri never moves a node between arenas); the source is left
+  untouched. Same import + `<template>`-content fixup as `clone_node`, and fails
+  closed on a failed import.
+* `Node#pointer_id` — the underlying `lxb_dom_node_t` pointer as an Integer,
+  matching `Nokogiri::XML::Node#pointer_id`. Shares the value `#hash`/`#eql?`
+  are built on, so it is a stable, Nokogiri-compatible identity key for
+  consumers (e.g. wrapper caches) that key nodes by pointer. Stable for a
+  node's lifetime; an address may be reused after a node is freed (same caveat
+  as Nokogiri).
+
+### Changed
+
+* Source gem: drop the Lexbor trees the build never compiles
+  (`test`/`utils`/`examples`/`benchmarks`/`wasm`/`packaging`; each is behind an
+  `IF(LEXBOR_BUILD_*)` guard and we build with them OFF), roughly halving the
+  packaged file count (~1115 → ~566). Precompiled gems are unaffected.
+
+### Internal
+
+* XPath: build the per-context compiled-AST cache key with `mkr_strndup`
+  (the expression is a `verified_text`, so its length is known) instead of
+  `mkr_strdup`, avoiding a `strlen` over already-length-bounded bytes.
+
 ## [0.1.0] - 2026-06-02
 
 First public release. An HTML5 parser, a native XPath 1.0 query engine, and CSS
@@ -98,5 +161,6 @@ libxml2 / libxslt dependency at any layer**.
   domxpath, CSS differential vs `Nokogiri::HTML5`). GitHub Actions CI across
   Ruby 3.2–4.0 × Ubuntu/macOS plus a sanitizer job.
 
-[Unreleased]: https://github.com/takahashim/makiri/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/takahashim/makiri/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/takahashim/makiri/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/takahashim/makiri/releases/tag/v0.1.0

data/ext/makiri/glue/glue.h

@@ -63,6 +63,12 @@ void mkr_import_fragment_children(lxb_dom_document_t *doc, lxb_dom_node_t *root,
 void mkr_emit_append(lxb_dom_node_t *imported, void *u);
 void mkr_emit_before(lxb_dom_node_t *imported, void *u);
 
+/* Node#clone_node(deep=false): shallow/deep DOM clone owned by this node's
+ * document (import_node + <template>-content fixup), detached from any parent.
+ * Implemented in ruby_doc.c (next to the import machinery), bound in
+ * mkr_init_node. */
+VALUE mkr_node_clone_node(int argc, VALUE *argv, VALUE self);
+
 /* NodeSet bridge (glue/ruby_node_set.c). */
 VALUE mkr_node_set_new(VALUE document);
 void  mkr_node_set_push(VALUE rb_set, lxb_dom_node_t *node);

data/ext/makiri/glue/ruby_doc.c

@@ -248,6 +248,61 @@ mkr_import_fragment_children(lxb_dom_document_t *doc, lxb_dom_node_t *root,
     }
 }
 
+/* Node#clone_node(deep = false): a shallow (or deep, with deep truthy) copy of
+ * this node, owned by the same document and detached from any parent — the DOM
+ * cloneNode, whose `deep` defaults to false (a missing/nil/false argument =>
+ * shallow). Built on the same import_node + <template>-content fixup the
+ * fragment parser uses, so a deep-cloned <template> carries its contents (which
+ * import_node alone omits). Fails closed: a NULL import (e.g. OOM) raises rather
+ * than returning a partial node. */
+VALUE
+mkr_node_clone_node(int argc, VALUE *argv, VALUE self)
+{
+    VALUE deep_v;
+    rb_scan_args(argc, argv, "01", &deep_v);
+    bool deep = RTEST(deep_v);
+
+    lxb_dom_node_t *node = mkr_node_unwrap(self);
+    lxb_dom_document_t *doc = node->owner_document;
+
+    lxb_dom_node_t *clone = lxb_dom_document_import_node(doc, node, deep);
+    if (clone == NULL) {
+        rb_raise(mkr_eError, "failed to clone node");
+    }
+    if (deep) {
+        mkr_fixup_template_content(doc, node, clone);
+    }
+    return mkr_wrap_node(clone, mkr_node_document(self));
+}
+
+/* Document#import_node(node, deep = false): a shallow (or deep, with deep
+ * truthy) copy of +node+ owned by THIS document — the DOM importNode, whose
+ * `deep` defaults to false (a missing/nil/false argument => shallow). Unlike
+ * Node#clone_node, the copy is owned by the receiver rather than the node's own
+ * document, so it is the way to bring a node across documents (Makiri never
+ * moves a node between arenas). The source is left untouched; the copy is
+ * detached. Same import + <template>-content fixup as clone_node; fails closed
+ * on a NULL import. */
+static VALUE
+mkr_doc_import_node(int argc, VALUE *argv, VALUE self)
+{
+    VALUE node_v, deep_v;
+    rb_scan_args(argc, argv, "11", &node_v, &deep_v);
+    bool deep = RTEST(deep_v);
+
+    lxb_dom_node_t   *src = mkr_node_unwrap(node_v);
+    lxb_dom_document_t *doc = mkr_doc_unwrap(self);
+
+    lxb_dom_node_t *imp = lxb_dom_document_import_node(doc, src, deep);
+    if (imp == NULL) {
+        rb_raise(mkr_eError, "failed to import node");
+    }
+    if (deep) {
+        mkr_fixup_template_content(doc, src, imp);
+    }
+    return mkr_wrap_node(imp, self);
+}
+
 /* Parse +rb_html+ as a fragment in the given (tag id, namespace) context and
  * build a DOCUMENT_FRAGMENT node owned by +document+ (so its nodes can be
  * spliced into that document). Lexbor's by-tag-id fragment parser implements
@@ -482,6 +537,7 @@ mkr_init_document(void)
     rb_define_method(mkr_cDocument, "internal_subset", mkr_doc_internal_subset, 0);
     rb_define_method(mkr_cDocument, "quirks_mode", mkr_doc_quirks_mode, 0);
     rb_define_method(mkr_cDocument, "fragment", mkr_doc_fragment, -1);
+    rb_define_method(mkr_cDocument, "import_node", mkr_doc_import_node, -1);
 
     rb_define_singleton_method(mkr_cDocumentFragment, "parse", mkr_frag_s_parse, -1);
 

data/ext/makiri/glue/ruby_mutate.c

@@ -408,6 +408,39 @@ mkr_doc_create_comment(VALUE self, VALUE rb_text)
     return mkr_wrap_node(lxb_dom_interface_node(c), self);
 }
 
+/* Document#create_processing_instruction(target, data) — DOM
+ * createProcessingInstruction: a detached ProcessingInstruction owned by this
+ * document. Lexbor validates the target, so an invalid one fails closed. */
+static VALUE
+mkr_doc_create_processing_instruction(VALUE self, VALUE rb_target, VALUE rb_data)
+{
+    lxb_dom_document_t *doc = mkr_doc_unwrap(self);
+    mkr_ruby_borrowed_text_t tv = mkr_ruby_verified_text(rb_target, "processing instruction target");
+    mkr_ruby_borrowed_text_t dv = mkr_ruby_verified_text(rb_data, "processing instruction data");
+    lxb_dom_processing_instruction_t *pi = lxb_dom_document_create_processing_instruction(
+        doc, (const lxb_char_t *)tv.ptr, tv.len, (const lxb_char_t *)dv.ptr, dv.len);
+    RB_GC_GUARD(tv.value);
+    RB_GC_GUARD(dv.value);
+    if (pi == NULL) {
+        rb_raise(mkr_eError, "failed to create processing instruction");
+    }
+    return mkr_wrap_node(lxb_dom_interface_node(pi), self);
+}
+
+/* Document#create_document_fragment — DOM createDocumentFragment: an empty
+ * DocumentFragment owned by this document (unlike #fragment / DocumentFragment.parse,
+ * which parse HTML; this makes an empty one to build up programmatically). */
+static VALUE
+mkr_doc_create_document_fragment(VALUE self)
+{
+    lxb_dom_document_t *doc = mkr_doc_unwrap(self);
+    lxb_dom_document_fragment_t *f = lxb_dom_document_create_document_fragment(doc);
+    if (f == NULL) {
+        rb_raise(mkr_eError, "failed to create document fragment");
+    }
+    return mkr_wrap_node(lxb_dom_interface_node(f), self);
+}
+
 void
 mkr_init_mutate(void)
 {
@@ -433,4 +466,8 @@ mkr_init_mutate(void)
     rb_define_method(mkr_cDocument, "create_element",   mkr_doc_create_element,   1);
     rb_define_method(mkr_cDocument, "create_text_node", mkr_doc_create_text_node, 1);
     rb_define_method(mkr_cDocument, "create_comment",   mkr_doc_create_comment,   1);
+    rb_define_method(mkr_cDocument, "create_processing_instruction",
+                     mkr_doc_create_processing_instruction, 2);
+    rb_define_method(mkr_cDocument, "create_document_fragment",
+                     mkr_doc_create_document_fragment, 0);
 }

data/ext/makiri/glue/ruby_node.c

@@ -1,5 +1,7 @@
 #include "glue.h"
 
+#include <lexbor/ns/ns.h>   /* lxb_ns_by_id, LXB_NS__UNDEF (namespaceURI) */
+
 /* ------------------------------------------------------------------ */
 /* Node wrapper type                                                  */
 /* ------------------------------------------------------------------ */
@@ -128,6 +130,179 @@ mkr_node_name(VALUE self)
     }
 }
 
+/* ------------------------------------------------------------------ */
+/* namespace (WHATWG DOM Element/Attr: namespaceURI/prefix/localName)  */
+/* ------------------------------------------------------------------ */
+
+/*
+ * Local name (DOM `localName`): the name without any prefix — "div" for
+ * <div>, "path" for an SVG <path>, "href" for an xlink:href attribute.
+ * Defined on Element and Attribute only; nil for the other node kinds (the DOM
+ * gives a Text/Comment/Document no localName).
+ */
+static VALUE
+mkr_node_local_name(VALUE self)
+{
+    lxb_dom_node_t *node = mkr_node_unwrap(self);
+    size_t len = 0;
+    const lxb_char_t *name;
+
+    switch (node->type) {
+    case LXB_DOM_NODE_TYPE_ELEMENT:
+        name = lxb_dom_element_local_name(lxb_dom_interface_element(node), &len);
+        break;
+    case LXB_DOM_NODE_TYPE_ATTRIBUTE:
+        name = lxb_dom_attr_local_name(lxb_dom_interface_attr(node), &len);
+        break;
+    default:
+        return Qnil;
+    }
+    return mkr_ruby_str_from_borrowed(mkr_borrowed_text((const char *)name, len));
+}
+
+/*
+ * Namespace prefix (DOM `prefix`): nil unless the qualified name is
+ * `prefix:local` — typically nil for HTML5-parsed content. Derived from the
+ * qualified-vs-local length (qualified == prefix ":" local), so a colon inside
+ * a local name can't be mistaken for a separator. Element/Attribute only.
+ */
+static VALUE
+mkr_node_prefix(VALUE self)
+{
+    lxb_dom_node_t *node = mkr_node_unwrap(self);
+    const lxb_char_t *q = NULL;
+    size_t qlen = 0, llen = 0;
+
+    switch (node->type) {
+    case LXB_DOM_NODE_TYPE_ELEMENT: {
+        lxb_dom_element_t *el = lxb_dom_interface_element(node);
+        q = lxb_dom_element_qualified_name(el, &qlen);
+        (void) lxb_dom_element_local_name(el, &llen);
+        break;
+    }
+    case LXB_DOM_NODE_TYPE_ATTRIBUTE: {
+        lxb_dom_attr_t *at = lxb_dom_interface_attr(node);
+        q = lxb_dom_attr_qualified_name(at, &qlen);
+        (void) lxb_dom_attr_local_name(at, &llen);
+        break;
+    }
+    default:
+        return Qnil;
+    }
+    if (q == NULL || qlen <= llen + 1) {   /* no "prefix:" segment */
+        return Qnil;
+    }
+    return mkr_ruby_str_from_borrowed(
+        mkr_borrowed_text((const char *)q, qlen - llen - 1));
+}
+
+/*
+ * The fixed namespaces the HTML parser assigns to foreign-content attributes by
+ * prefix (the "adjust foreign attributes" step). Lexbor tags an attribute node
+ * with its *element's* ns rather than the attribute's own, so an attribute's
+ * namespaceURI is resolved from its prefix here, not from node->ns. Returns
+ * NULL (=> DOM null) for any other prefix.
+ */
+static const char *
+mkr_attr_ns_for_prefix(const char *p, size_t n)
+{
+    if (n == 5 && memcmp(p, "xlink", 5) == 0) return "http://www.w3.org/1999/xlink";
+    if (n == 3 && memcmp(p, "xml",   3) == 0) return "http://www.w3.org/XML/1998/namespace";
+    if (n == 5 && memcmp(p, "xmlns", 5) == 0) return "http://www.w3.org/2000/xmlns/";
+    return NULL;
+}
+
+/*
+ * Namespace URI (DOM `namespaceURI`).
+ *
+ * Element: resolved from node->ns, so — DOM-faithfully — an HTML element is in
+ * the XHTML namespace ("http://www.w3.org/1999/xhtml"), not nil (an HTML
+ * element is never namespaceless; this is what browsers' DOM and `namespace-uri()`
+ * return). SVG/MathML elements get their own URI; nil only when truly
+ * unnamespaced (LXB_NS__UNDEF).
+ *
+ * Attribute: nil for an unprefixed attribute (class, id, ...); for a prefixed
+ * one, the parser-assigned foreign-content namespace keyed on the prefix
+ * (xlink/xml/xmlns), else nil.
+ *
+ * Other node kinds: nil.
+ */
+static VALUE
+mkr_node_namespace_uri(VALUE self)
+{
+    lxb_dom_node_t *node = mkr_node_unwrap(self);
+
+    if (node->type == LXB_DOM_NODE_TYPE_ELEMENT) {
+        if (node->ns == LXB_NS__UNDEF) {
+            return Qnil;
+        }
+        lxb_dom_document_t *doc = node->owner_document;
+        if (doc == NULL || doc->ns == NULL) {
+            return Qnil;
+        }
+        size_t len = 0;
+        const lxb_char_t *uri = lxb_ns_by_id(doc->ns, node->ns, &len);
+        if (uri == NULL || len == 0) {
+            return Qnil;
+        }
+        return mkr_ruby_str_from_borrowed(mkr_borrowed_text((const char *)uri, len));
+    }
+
+    if (node->type == LXB_DOM_NODE_TYPE_ATTRIBUTE) {
+        lxb_dom_attr_t *at = lxb_dom_interface_attr(node);
+        size_t qlen = 0, llen = 0;
+        const lxb_char_t *q = lxb_dom_attr_qualified_name(at, &qlen);
+        (void) lxb_dom_attr_local_name(at, &llen);
+        if (q == NULL || qlen <= llen + 1) {
+            return Qnil;   /* unprefixed attribute => no namespace */
+        }
+        const char *uri = mkr_attr_ns_for_prefix((const char *)q, qlen - llen - 1);
+        return uri ? rb_utf8_str_new_cstr(uri) : Qnil;
+    }
+
+    return Qnil;
+}
+
+/*
+ * Element#tag_name (DOM `tagName`): the qualified name, uppercased for an HTML
+ * element in an HTML document ("DIV"), as the DOM specifies — unlike #name,
+ * which is the lowercase qualified name. SVG/MathML elements keep their case.
+ * nil for non-element nodes.
+ */
+static VALUE
+mkr_node_tag_name(VALUE self)
+{
+    lxb_dom_node_t *node = mkr_node_unwrap(self);
+    if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
+        return Qnil;
+    }
+    size_t len = 0;
+    const lxb_char_t *name =
+        lxb_dom_element_tag_name(lxb_dom_interface_element(node), &len);
+    if (name == NULL) {
+        return Qnil;
+    }
+    return mkr_ruby_str_from_borrowed(mkr_borrowed_text((const char *)name, len));
+}
+
+/*
+ * ProcessingInstruction#target (DOM `target`): the PI's target name
+ * (the "xml" in <?xml ...?>). nil for non-PI nodes. The PI's data is read via
+ * #content / #text like any character-data node.
+ */
+static VALUE
+mkr_node_pi_target(VALUE self)
+{
+    lxb_dom_node_t *node = mkr_node_unwrap(self);
+    if (node->type != LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION) {
+        return Qnil;
+    }
+    size_t len = 0;
+    const lxb_char_t *t = lxb_dom_processing_instruction_target(
+        lxb_dom_interface_processing_instruction(node), &len);
+    return mkr_ruby_str_from_borrowed(mkr_borrowed_text((const char *)t, len));
+}
+
 /* Numeric DOM node type (LXB_DOM_NODE_TYPE_*). */
 static VALUE
 mkr_node_get_type(VALUE self)
@@ -549,19 +724,35 @@ mkr_node_equals(VALUE self, VALUE other)
     return mkr_node_unwrap(self) == mkr_node_unwrap(other) ? Qtrue : Qfalse;
 }
 
-/* Stable hash derived from the node pointer, so a == b implies a.hash ==
- * b.hash even across separately-created wrappers. */
+/* 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_hash(VALUE self)
+mkr_node_pointer_id(VALUE self)
 {
     lxb_dom_node_t *node = mkr_node_unwrap(self);
     return ULL2NUM((unsigned long long)(uintptr_t)node);
 }
 
+/* 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)
 {
-    rb_define_method(mkr_cNode, "name",       mkr_node_name,       0);
+    rb_define_method(mkr_cNode, "name",          mkr_node_name,          0);
+    rb_define_method(mkr_cNode, "namespace_uri", mkr_node_namespace_uri, 0);
+    rb_define_method(mkr_cNode, "prefix",        mkr_node_prefix,        0);
+    rb_define_method(mkr_cNode, "local_name",    mkr_node_local_name,    0);
+    rb_define_method(mkr_cNode, "tag_name",      mkr_node_tag_name,      0);
+    rb_define_method(mkr_cNode, "target",        mkr_node_pi_target,     0);
     rb_define_method(mkr_cNode, "node_type",  mkr_node_get_type,   0);
     rb_define_method(mkr_cNode, "content",    mkr_node_content,    0);
     rb_define_method(mkr_cNode, "text",       mkr_node_content,    0);
@@ -595,6 +786,8 @@ mkr_init_node(void)
     rb_define_method(mkr_cNode, "==",   mkr_node_equals, 1);
     rb_define_method(mkr_cNode, "eql?", mkr_node_equals, 1);
     rb_define_method(mkr_cNode, "hash", mkr_node_hash,   0);
+    rb_define_method(mkr_cNode, "pointer_id", mkr_node_pointer_id, 0);
+    rb_define_method(mkr_cNode, "clone_node", mkr_node_clone_node, -1);
 
     /* DocumentType identifiers (WHATWG DOM names; external_id is the
      * Nokogiri-compatible alias for public_id). */

data/ext/makiri/glue/ruby_xpath.c

@@ -540,7 +540,7 @@ mkr_ctx_cached_ast(mkr_xpath_ctx_data_t *d, mkr_verified_text_t expr,
         *owned = 1;
         return ast;
     }
-    char *key = mkr_strdup(expr.ptr);
+    char *key = mkr_strndup(expr.ptr, expr.len); /* expr is verified_text: len known, no strlen */
     if (key == NULL) {
         *owned = 1;
         return ast;

data/lib/makiri/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Makiri
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end