makiri 0.12.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6432135ca3963c17f432c152ede49162c3f1be48e96179b914c971f0b2da1b76
-  data.tar.gz: 2b0478171ee224ea5c29ae19cd0a16a08c3d786e017444241d4bb8f620ecf975
+  metadata.gz: 48c6dfd55ed565531aea117967aee1f4b8f3405ff0e36ca8766ffa729a1ee27e
+  data.tar.gz: 1866e9eb174ea0a6428a8f1c81f65ed8756d61c2429de935876d60547a4bc6bd
 SHA512:
-  metadata.gz: 8447a816ba507fb6a74ed8e6a5a92deaff6da2453ef29ba6cfe24652ec160b440409ec94b58b4aa89d3d28ab05643086f4dd1bba150339eeff27819d2e3d86d7
-  data.tar.gz: 2a9505ac1b1762cbdbc738645542acbda4bb029e06e5b4befe76f63e39e6e55a9f36a34106dd0fe24d3103d17f020939498373d9c872cb2042d71b23bb0d6513
+  metadata.gz: f847d9d772a2865bcd6e3f9b1626f0b67e4215d14d844b529bd194e9d287aa288cc2a555156799f842ac68fcc13405e1cfff317a506c2476b87eb24646f17c46
+  data.tar.gz: ee1fe65b9055dc2a9c11cdbbd789544ef72ef1bd2c8fa731ab0eab2f97173125ab3f96637da903d33df76dfa80e221dd0e11abeaa446f5683e1428cc7f6552af

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.13.0] - 2026-10-03
+
+### Added
+
+* `Document#tree_version` (HTML and XML): an Integer that increases whenever
+  a child list in the document changes - nodes added, removed or replaced,
+  `inner_html=`, `content=`, and both documents when a node moves between
+  them. Attribute changes leave it as it is, so it can key a cache of child
+  lists.
+* `Element#attribute_value_ns(ns, local)` and `#attribute_node_ns(ns, local)`
+  (HTML and XML): the attribute's value or Attr node by namespace and local
+  name, like the DOM's `getAttributeNS` / `getAttributeNodeNS`. `nil` or `""`
+  means no namespace.
+* `Element#set_loose_dom_attribute(name, value)` now works on HTML nodes too.
+  Like the DOM's `setAttribute`, it sets an attribute in no namespace whose
+  name may contain a colon (`v-on:click`).
+
+### Fixed
+
+* HTML documents keep namespace URIs as written. `create_element_ns`,
+  `set_attribute_ns` and `import_node` lower-cased them (`fooNamespace` read
+  back as `foonamespace`), and a differently cased XHTML namespace URI made
+  an HTML element.
+
 ## [0.12.1] - 2026-10-02
 
 ### Fixed

data/README.md

@@ -50,7 +50,7 @@ doc = Makiri::HTML(<<~HTML)
   </body></html>
 HTML
 
-# CSS selectors (Lexbor's selector engine)
+# CSS selectors (Lexbor's selector parser, Makiri's own matcher)
 doc.css("a").map { |a| a["href"] }      # => ["/a", "/b"]
 doc.at_css("p.lead").text               # => "Hello"
 
@@ -184,6 +184,27 @@ and unusually large documents can raise it with `max_bytes:`.
 Makiri::XML(huge_xml, max_bytes: 512 * 1024 * 1024)   # also Makiri::XML::Document.parse(..., max_bytes:)
 ```
 
+### Node identity
+
+Navigating to the same node always gives the same Ruby object, for as long as
+its document is alive. The document keeps every wrapper it has handed out, so
+instance variables, singleton methods and `freeze` set on a node survive
+garbage collection and are there the next time the node is reached.
+
+That makes a node a safe place to keep per-node state, such as a wrapper
+object of your own:
+
+```ruby
+el = doc.at_css("p")
+el.instance_variable_set(:@wrapper, MyElement.new(el))
+doc.at_css("p").instance_variable_get(:@wrapper)   # => the same MyElement
+```
+
+A node created by `clone_node` or `import_node` is a new node with no state.
+`pointer_id` is unique only among live nodes: once a document is freed, a node
+of another document may reuse its value. So key a pointer-based cache per
+document, not across documents.
+
 ## Non-goals (v1.0)
 
 * XSLT, DTD / Schema / RelaxNG validation, XPointer, XInclude.
@@ -224,6 +245,7 @@ See also [`spec/conformance/README.md`](spec/conformance/README.md).
 | XPath 1.0 | XML | `Nokogiri::XML` — differential | `conformance:xpath_xml` |
 | Parsed tree (property-based) | XML | `Nokogiri::XML` — differential | `conformance:xml_pbt` |
 | CSS selectors | XML | `Nokogiri::XML` — differential | `conformance:css_xml` |
+| XML Builder | Ruby DSL | `Nokogiri::XML::Builder` — differential | `conformance:builder` |
 
 ## Requirements
 

data/ext/makiri/rust/build.rs

@@ -186,7 +186,13 @@ fn main() {
         .allowlist_function("lxb_dom_document_type_system_id")
         .allowlist_function("lxb_dom_processing_instruction_target")
         .allowlist_function("lxb_ns_by_id")
-        .allowlist_function("lxb_ns_data_by_link")
+        // A namespace URI interned and looked up AS WRITTEN: Lexbor's own
+        // `lxb_ns_append` / `lxb_ns_data_by_link` fold ASCII case, where the
+        // DOM keeps a namespace an opaque string (`HtmlDoc::intern_ns`).
+        .allowlist_function("lexbor_hash_search")
+        .allowlist_function("lexbor_hash_insert")
+        .allowlist_var("lexbor_hash_search_raw")
+        .allowlist_var("lexbor_hash_insert_raw")
         .allowlist_function("lxb_dom_document_root")
         .allowlist_type("lxb_html_token_t")
         .allowlist_type("lxb_html_token_type_t")

data/ext/makiri/rust/src/bridge/html.rs

@@ -324,10 +324,26 @@ impl<'a> HtmlEdit<'a> {
     /// not the token's - so a caller keeps the span from here to the change
     /// to engine calls and checks that call no Ruby (`insert` reads its
     /// argument's node and frozen flag there, and nothing more).
+    ///
+    /// It counts as a change to a child list ([`bump_tree_version`]); an
+    /// attribute edit takes [`HtmlEdit::node_for_attributes`] instead.
     pub fn node(self) -> Result<HtmlNodeMut<'a>, Error> {
+        self.mutable(true)
+    }
+
+    /// [`HtmlEdit::node`] for an edit of the element's ATTRIBUTES only, which
+    /// changes no child list and so leaves the tree version alone.
+    pub fn node_for_attributes(self) -> Result<HtmlNodeMut<'a>, Error> {
+        self.mutable(false)
+    }
+
+    fn mutable(self, structural: bool) -> Result<HtmlNodeMut<'a>, Error> {
         crate::bridge::ruby::check_frozen(self.this.value)?;
         ensure_document_mutable(self.this.document)?;
         invalidate_indexes(self.this.document);
+        if structural {
+            bump_tree_version(self.this.document);
+        }
         // SAFETY: the receiver is not frozen and no XPath evaluation is
         // reading its document - both checked just now.
         Ok(unsafe { HtmlNodeMut::assume_mutable(self.this.raw().as_node()) })
@@ -369,7 +385,9 @@ fn adopt_release(src: Value) -> Result<(), Error> {
         release_from_tree(unsafe { HtmlNodeMut::assume_mutable(node) });
     })?;
     /* After the borrow `with_arg_node` held: dropping them borrows again. */
-    invalidate_indexes(keepalive_document(src)?);
+    let src_doc = keepalive_document(src)?;
+    invalidate_indexes(src_doc);
+    bump_tree_version(src_doc);
     Ok(())
 }
 

data/ext/makiri/rust/src/bridge/wrapper.rs

@@ -322,6 +322,9 @@ pub struct DocData {
     /// what [`account_growth`] compares against, since the byte count
     /// itself costs a walk of every chunk.
     reported_chunks: usize,
+    /// `Document#tree_version`: bumped by every edit that can change a child
+    /// list of a node this document owns (see [`bump_tree_version`]).
+    tree_version: u64,
     /// One wrapper per node; see [`NodeCache`].
     ///
     /// Boxed and optional so a document nobody navigates never allocates a
@@ -590,6 +593,7 @@ impl DocumentShell {
                     errors: QFALSE,
                     reported: 0,
                     reported_chunks: 0,
+                    tree_version: 0,
                     nodes: None,
                 },
                 |d| d.errors = errors.as_raw(),
@@ -880,6 +884,28 @@ pub fn keepalive_document(rb_node: Value) -> Result<Value, Error> {
     Ok(unsafe { value(nd.document) })
 }
 
+/* ---- the tree version ---- */
+
+/// Count a change to a child list of a node `rb_doc` owns - attached,
+/// detached or inside a fragment alike. Called where an edit is handed its
+/// mutable node (`HtmlEdit::node`, `Editing::with_arena`) and for the source
+/// of an adoption, so no structural mutator can miss it; attribute edits take
+/// the paths that skip it, as they change no child list.
+///
+/// Bumped inside the edit, with no Ruby run between the bump and the change,
+/// so nothing can read the tree in between and cache it under the new number.
+/// An edit that then fails costs a reader a cache refill, never a stale
+/// answer.
+pub fn bump_tree_version(rb_doc: Value) {
+    with_doc_data_known(rb_doc, |d| d.tree_version = d.tree_version.wrapping_add(1));
+}
+
+/// `Document#tree_version`: how many structural edits the document has seen.
+/// `TypeError` for a non-Document.
+pub fn tree_version(rb_doc: Value) -> Result<u64, Error> {
+    Ok(DOC_TYPE.get(&rb_doc)?.tree_version)
+}
+
 /* ---- the document's mutation gate ---- */
 
 /// `Err(Makiri::Error)` while an evaluation with a handler is reading `rb_doc`.

data/ext/makiri/rust/src/bridge/xml.rs

@@ -330,13 +330,36 @@ impl Editing {
     /// it indexes. Not in `begin_edit`: the argument conversion between the two
     /// runs `#to_s`, and a query there rebuilt the index from the tree about to
     /// change - `//a` then kept finding an element renamed to `b`.
+    ///
+    /// It counts as a change to a child list ([`bump_tree_version`]); an
+    /// attribute edit takes [`Editing::with_attributes`] instead.
     pub fn with_arena<R>(&self, f: impl FnOnce(&mut XmlDoc, NodeId) -> R) -> Result<R, Error> {
+        self.lend(true, f)
+    }
+
+    /// [`Editing::with_arena`] for an edit of the element's ATTRIBUTES only,
+    /// which changes no child list and so leaves the tree version alone.
+    pub fn with_attributes<R>(&self, f: impl FnOnce(&mut XmlDoc, NodeId) -> R) -> Result<R, Error> {
+        self.lend(false, f)
+    }
+
+    fn lend<R>(
+        &self,
+        structural: bool,
+        f: impl FnOnce(&mut XmlDoc, NodeId) -> R,
+    ) -> Result<R, Error> {
         let id = self.id;
         check_frozen(self.receiver)?;
-        with_arena_for_new_node(self.document, |d| {
+        let r = with_arena_for_new_node(self.document, |d| {
             d.invalidate_name_index();
             f(d, id)
-        })
+        });
+        /* After the arena call, which refuses an evaluated document first -
+         * and that, like the frozen check, leaves the tree as it was. */
+        if structural && r.is_ok() {
+            bump_tree_version(self.document);
+        }
+        r
     }
 }
 
@@ -559,6 +582,25 @@ pub fn find_attribute(this: XmlSelf, name: Value) -> Result<Option<NodeId>, Erro
     Ok(find_attribute_bytes(this.doc_ref(), id, bytes))
 }
 
+/// The attribute of `el` in namespace `ns` (nil or "" for none) with local
+/// name `local` - DOM "get an attribute by namespace and local name", the key
+/// `remove_attribute_ns` removes by. Converted before the arena is borrowed,
+/// as [`find_attribute`].
+pub fn find_attribute_ns(this: XmlSelf, ns: Value, local: Value) -> Result<Option<NodeId>, Error> {
+    let id = this.id;
+    if this.doc_ref().type_(id) != Some(ArenaKind::Element) {
+        return Ok(None);
+    }
+    let lv = ruby_verified_text(local, "attribute local name")?;
+    let nv = crate::bridge::string::namespace_arg(ns, "namespace")?;
+    let key = crate::xml::attr_key::AttrKey::Ns {
+        ns: nv.as_ref().map_or(&b""[..], |n| n.as_bytes()),
+        local: lv.as_bytes(),
+    };
+    let d = this.doc_ref();
+    Ok(d.attributes(id).find(|&a| key.matches(d, a)))
+}
+
 /// The attribute of `el` whose qualified name is `name`.
 ///
 /// Namespace declarations included: in the DOM an `xmlns` / `xmlns:p` is an
@@ -585,6 +627,8 @@ fn find_attribute_bytes(d: &XmlDoc, el: NodeId, name: &[u8]) -> Option<NodeId> {
 /// cannot fail - there is nothing left to look up.
 pub struct Adoption {
     src_doc: *mut XmlDoc,
+    /// The source's Document, whose tree version the removal bumps.
+    src_document: Value,
     src: NodeId,
     /// The source node's wrapper, which keeps its document - and so
     /// `src_doc` - alive until the adoption is finished.
@@ -606,6 +650,7 @@ impl Adoption {
             remove_node(sdoc, self.src);
         }
         sdoc.invalidate_name_index();
+        bump_tree_version(self.src_document);
     }
 }
 
@@ -644,6 +689,7 @@ pub fn incoming_node(target_doc: Value, arg: Value) -> Result<(NodeId, Option<Ad
         copy,
         Some(Adoption {
             src_doc,
+            src_document,
             src,
             _keep: arg,
         }),

data/ext/makiri/rust/src/glue/html_doc.rs

@@ -167,6 +167,10 @@ pub fn init_html_doc() -> Result<(), Error> {
     html_doc.define_method("quirks_mode", method!(doc_quirks_mode, 0))?;
     html_doc.define_method("fragment", method!(doc_fragment, -1))?;
     html_doc.define_method("import_node", method!(doc_import_node, -1))?;
+    html_doc.define_method(
+        "tree_version",
+        method!(crate::glue::node::document_tree_version, 0),
+    )?;
 
     let frag = crate::init::CLASS_DOCUMENT_FRAGMENT.defined()?;
     frag.define_singleton_method("parse", method!(frag_s_parse, -1))?;

data/ext/makiri/rust/src/glue/html_node/mod.rs

@@ -110,6 +110,8 @@ fn init_read() -> Result<(), Error> {
         "attribute_value_by_qualified_name",
         method!(read::attribute_value_by_qualified_name, 1),
     )?;
+    m.define_method("attribute_value_ns", method!(read::attribute_value_ns, 2))?;
+    m.define_method("attribute_node_ns", method!(read::attribute_node_ns, 2))?;
     m.define_method("value", method!(read::value, 0))?;
     m.define_method("line", method!(read::line, 0))?;
 
@@ -158,7 +160,12 @@ fn init_mutate() -> Result<(), Error> {
     m.define_method("inner_html=", method!(mutate::set_inner_html, 1))?;
     m.define_method("outer_html=", method!(mutate::set_outer_html, 1))?;
 
-    m.define_method("[]=", method!(mutate::aset, 2))?;
+    /* `[]=` is the DOM's setAttribute already (no-namespace, the whole name as
+     * the local name, lower-cased on an HTML element); the XML name for that
+     * is `set_loose_dom_attribute`, so it answers here too. */
+    for name in ["[]=", "set_loose_dom_attribute"] {
+        m.define_method(name, method!(mutate::aset, 2))?;
+    }
     m.define_method("set_attribute_ns", method!(mutate::set_attribute_ns, 3))?;
     m.define_method(
         "remove_attribute_ns",

data/ext/makiri/rust/src/glue/html_node/mutate.rs

@@ -75,8 +75,9 @@ fn extract<'q>(
 /// The receiver as an element, once every argument is converted. Its node type
 /// was checked before the conversion (an argument cannot change it), so the
 /// `None` arm is unreachable - it answers `refusal` rather than assuming so.
+/// For the attribute mutators only: it leaves the tree version alone.
 fn element_of<'a>(edit: HtmlEdit<'a>, refusal: &'static str) -> Result<HtmlElementMut<'a>, Error> {
-    edit.node()?
+    edit.node_for_attributes()?
         .element_mut()
         .ok_or_else(|| makiri_error(refusal))
 }

data/ext/makiri/rust/src/glue/html_node/read.rs

@@ -23,7 +23,7 @@ use crate::bridge::node_set::node_set_with_fill;
 use crate::bridge::ruby::is_kind_of;
 use crate::bridge::string::ruby_verified_text;
 use crate::init::{CLASS_NODE, CLASS_XML_DOCUMENT};
-use crate::lexbor::adapter::html::{HtmlNode, NodeType, RawNode};
+use crate::lexbor::adapter::html::{HtmlAttr, HtmlElement, HtmlNode, NodeType, RawNode};
 
 /* ------------------------------------------------------------------ *
  * small helpers                                                      *
@@ -469,6 +469,63 @@ pub fn attribute_value_by_qualified_name(
     })
 }
 
+/// The attribute of `el` in namespace `rb_ns` (nil or "" for none) with local
+/// name `rb_local` - DOM "get an attribute by namespace and local name", the
+/// key `remove_attribute_ns` removes by. The namespace compares exactly.
+fn attr_by_ns_arg<'d>(
+    el: HtmlElement<'d>,
+    rb_ns: Value,
+    rb_local: Value,
+) -> Result<Option<HtmlAttr<'d>>, Error> {
+    let lv = ruby_verified_text(rb_local, "attribute local name")?;
+    let nv = crate::bridge::string::namespace_arg(rb_ns, "namespace")?;
+    /* Looked up, not interned: a namespace the document never interned is
+     * one no attribute here carries. */
+    let want_ns = match nv.as_ref() {
+        Some(uri) => match el.node().owner_document().lookup_ns(uri.as_bytes()) {
+            Some(id) => Some(id),
+            None => return Ok(None),
+        },
+        None => None,
+    };
+    Ok(el.attr_by_ns(want_ns, lv.as_bytes()))
+}
+
+/// `#attribute_value_ns(ns, local)` (DOM `getAttributeNS`): the value of the
+/// attribute in namespace `ns` (nil or "" for none) with local name `local`,
+/// or nil - for a non-element too.
+pub fn attribute_value_ns(
+    _ruby: &Ruby,
+    this: super::HtmlSelf,
+    rb_ns: Value,
+    rb_local: Value,
+) -> Result<Option<Value>, Error> {
+    crate::bridge::ruby::entry(|| {
+        let Some(el) = this.node().element() else {
+            return Ok(None);
+        };
+        let found = attr_by_ns_arg(el, rb_ns, rb_local)?;
+        Ok(found.map(|at| dom_str(at.value())))
+    })
+}
+
+/// `#attribute_node_ns(ns, local)` (DOM `getAttributeNodeNS`): the Attr
+/// [`attribute_value_ns`] reads, or nil.
+pub fn attribute_node_ns(
+    _ruby: &Ruby,
+    this: super::HtmlSelf,
+    rb_ns: Value,
+    rb_local: Value,
+) -> Result<Option<Value>, Error> {
+    crate::bridge::ruby::entry(|| {
+        let Some(el) = this.node().element() else {
+            return Ok(None);
+        };
+        let found = attr_by_ns_arg(el, rb_ns, rb_local)?;
+        wrap_node(found.map(|at| at.node()), this.document)
+    })
+}
+
 /// `attr.value`. For a non-attribute node this falls back to text content,
 /// matching the loose Nokogiri-ish meaning of `#value`.
 pub fn value(ruby: &Ruby, this: super::HtmlSelf) -> Result<Value, Error> {

data/ext/makiri/rust/src/glue/node.rs

@@ -40,3 +40,12 @@ pub fn node_pointer_id(ruby: &Ruby, rb_self: Value) -> Result<Integer, magnus::E
 pub fn node_hash(ruby: &Ruby, rb_self: Value) -> Result<Integer, magnus::Error> {
     crate::bridge::ruby::entry(|| node_pointer_id(ruby, rb_self))
 }
+
+/// `Document#tree_version`: an Integer that grows with every edit that can
+/// change a child list of a node the document owns (attached, detached or in
+/// a fragment) - add, remove, replace, `inner_html=`, `content=` and the
+/// like, and both documents of a move between them. Attribute edits leave it
+/// alone. A reader caching a child list keys it by this.
+pub fn document_tree_version(rb_self: Value) -> Result<u64, magnus::Error> {
+    crate::bridge::ruby::entry(|| crate::bridge::wrapper::tree_version(rb_self))
+}

data/ext/makiri/rust/src/glue/xml_doc.rs

@@ -140,6 +140,10 @@ pub fn init_xml_doc() -> Result<(), Error> {
     doc.define_method("root", method!(doc_root, 0))?;
     doc.define_method("internal_subset", method!(doc_internal_subset, 0))?;
     doc.define_method("fragment", method!(doc_fragment, 1))?;
+    doc.define_method(
+        "tree_version",
+        method!(crate::glue::node::document_tree_version, 0),
+    )?;
 
     CLASS_XML_DOCUMENT_FRAGMENT
         .defined()?

data/ext/makiri/rust/src/glue/xml_node/mod.rs

@@ -83,6 +83,8 @@ fn init_read() -> Result<(), Error> {
         "attribute_by_qualified_name",
         method!(read::attribute_by_qualified_name, 1),
     )?;
+    m.define_method("attribute_value_ns", method!(read::attribute_value_ns, 2))?;
+    m.define_method("attribute_node_ns", method!(read::attribute_node_ns, 2))?;
 
     /* Node identity by the underlying pointer, so #path, NodeSet dedup, Set and
      * Hash all work - the same contract HTML nodes have, from the same code. */

data/ext/makiri/rust/src/glue/xml_node/mutate.rs

@@ -65,7 +65,7 @@ pub fn aset(_ruby: &Ruby, this: XmlSelf, name: Value, val: Value) -> Result<Valu
         let nv = verified_name(name, "attribute name")?;
         let vv = verified_data(val, "attribute value")?;
         let (name, value) = (nv.as_bytes(), vv.as_bytes());
-        xml_mut_result(edit.with_arena(|d, n| mutate::set_attribute(d, n, name, value))?)?;
+        xml_mut_result(edit.with_attributes(|d, n| mutate::set_attribute(d, n, name, value))?)?;
         Ok(val)
     })
 }
@@ -88,7 +88,9 @@ pub fn set_attribute_ns(
             qv.as_bytes(),
             vv.as_bytes(),
         );
-        xml_mut_result(edit.with_arena(|d, n| mutate::set_attribute_ns(d, n, ns, qname, value))?)?;
+        xml_mut_result(
+            edit.with_attributes(|d, n| mutate::set_attribute_ns(d, n, ns, qname, value))?,
+        )?;
         Ok(val)
     })
 }
@@ -110,7 +112,7 @@ pub fn set_loose_dom_attribute(
         let vv = verified_data(val, "attribute value")?;
         let (name, value) = (nv.as_bytes(), vv.as_bytes());
         xml_mut_result(
-            edit.with_arena(|d, n| mutate::set_loose_dom_attribute(d, n, name, value))?,
+            edit.with_attributes(|d, n| mutate::set_loose_dom_attribute(d, n, name, value))?,
         )?;
         Ok(val)
     })
@@ -133,7 +135,7 @@ pub fn remove_attribute_ns(
         let nv = namespace_arg(ns, "namespace")?;
         let ns = nv.as_ref().map_or(&b""[..], |n| n.as_bytes());
         let local = lv.as_bytes();
-        edit.with_arena(|d, n| mutate::remove_attribute_ns(d, n, ns, local))?;
+        edit.with_attributes(|d, n| mutate::remove_attribute_ns(d, n, ns, local))?;
         Ok(rb_self)
     })
 }
@@ -148,7 +150,7 @@ pub fn delete(_ruby: &Ruby, this: XmlSelf, name: Value) -> Result<Value, Error>
         }
         let nv = verified_text(name, "attribute name")?;
         let name = nv.as_bytes();
-        edit.with_arena(|d, n| mutate::remove_attribute(d, n, name))?;
+        edit.with_attributes(|d, n| mutate::remove_attribute(d, n, name))?;
         Ok(rb_self)
     })
 }

data/ext/makiri/rust/src/glue/xml_node/read.rs

@@ -281,6 +281,34 @@ pub fn aref(ruby: &Ruby, this: XmlSelf, rb_name: Value) -> Result<Option<Value>,
     })
 }
 
+/// `#attribute_value_ns(ns, local)` (DOM `getAttributeNS`): the value of the
+/// attribute in namespace `ns` (nil or "" for none) with local name `local`,
+/// or nil - for a non-element too.
+pub fn attribute_value_ns(
+    ruby: &Ruby,
+    this: XmlSelf,
+    rb_ns: Value,
+    rb_local: Value,
+) -> Result<Option<Value>, Error> {
+    crate::bridge::ruby::entry(|| {
+        let found = crate::bridge::xml::find_attribute_ns(this, rb_ns, rb_local)?;
+        Ok(str_or_nil(ruby, found.map(|at| this.doc_ref().value(at))))
+    })
+}
+
+/// `#attribute_node_ns(ns, local)` (DOM `getAttributeNodeNS`): the Attr
+/// [`attribute_value_ns`] reads, or nil.
+pub fn attribute_node_ns(
+    this: XmlSelf,
+    rb_ns: Value,
+    rb_local: Value,
+) -> Result<Option<Value>, Error> {
+    crate::bridge::ruby::entry(|| {
+        let found = crate::bridge::xml::find_attribute_ns(this, rb_ns, rb_local)?;
+        wrap_rel(this, found)
+    })
+}
+
 /// The Attr NODE with that qualified name.
 pub fn attribute_by_qualified_name(this: XmlSelf, rb_name: Value) -> Result<Option<Value>, Error> {
     crate::bridge::ruby::entry(|| {

data/ext/makiri/rust/src/lexbor/adapter/html/attrs.rs

@@ -209,21 +209,31 @@ impl<'doc> HtmlElement<'doc> {
         value: &[u8],
         lower: bool,
     ) -> Result<HtmlAttr<'doc>, AdapterOom> {
+        /* Interned as written first: Lexbor's set_name_ns below interns the
+         * URI too, case-folded, and its id is replaced by this one. */
+        let ns_id = match ns {
+            Some(uri) => Some(self.node().owner_document().intern_ns(uri).or_oom()?),
+            None => None,
+        };
         // SAFETY: a live element of a live document; every slice is read and
         // copied by Lexbor, and the attribute is one nothing else holds.
         unsafe {
             let at = lxb::lxb_dom_attr_interface_create(self.node().owner_document().as_raw());
             let at = HtmlAttr::link(at).or_oom()?;
-            let named = match ns {
-                Some(uri) => lxb::lxb_dom_attr_set_name_ns(
-                    at.raw(),
-                    uri.as_ptr(),
-                    uri.len(),
-                    qname.as_ptr(),
-                    qname.len(),
-                    false,
-                ),
-                None => {
+            let named = match (ns, ns_id) {
+                (Some(uri), Some(id)) => {
+                    let st = lxb::lxb_dom_attr_set_name_ns(
+                        at.raw(),
+                        uri.as_ptr(),
+                        uri.len(),
+                        qname.as_ptr(),
+                        qname.len(),
+                        false,
+                    );
+                    (*at.raw()).node.ns = id.raw();
+                    st
+                }
+                _ => {
                     (*at.raw()).node.ns = (*self.raw()).node.ns;
                     lxb::lxb_dom_attr_set_name(at.raw(), qname.as_ptr(), qname.len(), lower)
                 }
@@ -431,6 +441,21 @@ unsafe fn repair_element(
             unsafe { de.link_attr(copy, None) };
         }
     }
+    /* Lexbor's copy re-interns a namespace past the built-in ones in this
+     * document case-folded (`lxb_dom_node_interface_copy`), so `fooNamespace`
+     * would arrive as `foonamespace`: such a copy gets its source's URI as
+     * written, element and attributes alike. An attribute with no namespace
+     * of its own carries its element's, and gets the same id the element
+     * does. */
+    if se.node().owner_document() != doc {
+        // SAFETY: the copy is unshared, per the contract.
+        unsafe {
+            restore_ns(doc, se.node(), de.node())?;
+            for (sa, da) in se.attrs().zip(de.attrs()) {
+                restore_ns(doc, sa.node(), da.node())?;
+            }
+        }
+    }
     /* The lists now match one for one, so each shortcut goes to the copy of
      * the attribute that holds it in the source - which the source keeps as
      * the DOM's ID / class attribute. */
@@ -450,3 +475,23 @@ unsafe fn repair_element(
     }
     Ok(())
 }
+
+/// Give `dst`, a copy of `src` from another document, `src`'s namespace as
+/// written - for one past the built-in ones, whose id Lexbor's copy re-interned
+/// case-folded. A built-in id is the same number in every document.
+///
+/// # Safety
+/// `dst` is a node of a copy nothing but the caller holds, in `doc`.
+unsafe fn restore_ns(
+    doc: HtmlDoc<'_>,
+    src: HtmlNode<'_>,
+    dst: HtmlNode<'_>,
+) -> Result<(), AdapterOom> {
+    if src.ns_id().is_none_or(|id| id.is_static()) {
+        return Ok(());
+    }
+    let id = doc.intern_ns(src.ns_uri().or_oom()?).or_oom()?;
+    // SAFETY: per the contract; `id` is interned in `doc`'s table.
+    unsafe { (*dst.as_raw()).ns = id.raw() };
+    Ok(())
+}

data/ext/makiri/rust/src/lexbor/adapter/html/build.rs

@@ -47,6 +47,22 @@ impl<'doc> HtmlDoc<'doc> {
         if has_ascii_uppercase(local) && self.lookup_ns(ns) == Some(NsId::HTML) {
             return self.create_html_element_as_written(local, prefix);
         }
+        /* The namespace is interned here, as written, and only a built-in
+         * one is named to Lexbor - by its exact URI, which its case-folding
+         * lookup maps back to the same id. Any other is created in no
+         * namespace and given its id after: handed to Lexbor, `fooNamespace`
+         * would be interned lower-cased, and `HTTP://WWW.W3.ORG/1999/XHTML`
+         * would make an HTML element. In no namespace and in a namespace past
+         * the built-in ones, Lexbor builds the same plain element struct. */
+        let ns_id = if ns.is_empty() {
+            None
+        } else {
+            Some(self.intern_ns(ns)?)
+        };
+        let lexbor_ns: &[u8] = match ns_id {
+            Some(id) if id.is_static() => ns,
+            _ => &[],
+        };
         let or_null = |s: &[u8]| {
             if s.is_empty() {
                 core::ptr::null()
@@ -66,8 +82,8 @@ impl<'doc> HtmlDoc<'doc> {
                 self.as_raw(),
                 local.as_ptr(),
                 local.len(),
-                or_null(ns),
-                ns.len(),
+                or_null(lexbor_ns),
+                lexbor_ns.len(),
                 core::ptr::null(),
                 0,
                 core::ptr::null(),
@@ -75,6 +91,11 @@ impl<'doc> HtmlDoc<'doc> {
                 false,
             ))
         }?;
+        if let Some(id) = ns_id.filter(|id| !id.is_static()) {
+            // SAFETY: an element just made in this document, in no tree; `id`
+            // is interned in its namespace table.
+            unsafe { (*el.0.raw()).node.ns = id.raw() };
+        }
         let (p, p_len) = if prefix.is_empty() {
             if !has_ascii_uppercase(local) {
                 return Some(el);

data/ext/makiri/rust/src/lexbor/adapter/html/mod.rs

@@ -75,6 +75,20 @@ const fn nonzero(v: usize) -> NonZeroUsize {
     }
 }
 
+/// The built-in namespace whose URI is exactly `uri`, as Lexbor spells it.
+/// Byte for byte: Lexbor's own static lookup folds ASCII case.
+fn static_ns(uri: &[u8]) -> Option<NsId> {
+    /* From HTML: `UNDEF` and `ANY` have no URI. */
+    (lxb::lxb_ns_id_enum_t_LXB_NS_HTML as usize..lxb::lxb_ns_id_enum_t_LXB_NS__LAST_ENTRY as usize)
+        .find_map(|id| {
+            let mut len = 0;
+            // SAFETY: a static id, which `lxb_ns_by_id` answers from Lexbor's
+            // static table without reading the (here null) document table.
+            let link = unsafe { seen(lxb::lxb_ns_by_id(core::ptr::null_mut(), id, &mut len), len) };
+            (link == uri).then(|| NsId::from_raw(id)).flatten()
+        })
+}
+
 /// An interned namespace id of a document's namespace table - never
 /// `LXB_NS__UNDEF`, which reads as `None`.
 ///
@@ -589,19 +603,31 @@ impl<'doc> HtmlDoc<'doc> {
     /// interning it. `None` for an empty URI and for one never interned - no
     /// node or attribute can carry a namespace the table does not hold.
     ///
-    /// Lexbor folds ASCII case in namespace URIs (it stores and looks them up
-    /// lower-cased), so `URN:X` finds what `urn:x` interned.
+    /// Exact, as the DOM compares namespaces: `fooNamespace` is not
+    /// `foonamespace`, and `HTTP://WWW.W3.ORG/1999/XHTML` is not the HTML
+    /// namespace. Lexbor's own `lxb_ns_data_by_link` folds ASCII case in both,
+    /// so neither it nor `lxb_ns_append` is called with a URI from outside;
+    /// see [`intern_ns`](Self::intern_ns).
     pub fn lookup_ns(self, uri: &[u8]) -> Option<NsId> {
         if uri.is_empty() {
             return None;
         }
-        // SAFETY: a live document; the table and the URI are only read.
+        if let Some(id) = static_ns(uri) {
+            return Some(id);
+        }
+        // SAFETY: a live document; the table and the URI are only read, and
+        // every entry of the namespace table is an `lxb_ns_data_t`.
         let id = unsafe {
             let table = (*self.as_raw()).ns;
             if table.is_null() {
                 return None;
             }
-            let d = lxb::lxb_ns_data_by_link(table, uri.as_ptr(), uri.len());
+            let d = lxb::lexbor_hash_search(
+                table,
+                lxb::lexbor_hash_search_raw,
+                uri.as_ptr(),
+                uri.len(),
+            ) as *const lxb::lxb_ns_data_t;
             if d.is_null() {
                 return None;
             }
@@ -610,24 +636,42 @@ impl<'doc> HtmlDoc<'doc> {
         NsId::from_raw(id)
     }
 
-    /// The id of `uri` in this document's namespace table, interning it if
-    /// the table does not hold it yet. `None` for an empty URI or when Lexbor
-    /// could not intern it. Case is folded as in [`lookup_ns`](Self::lookup_ns).
+    /// The id of `uri` in this document's namespace table, interning it AS
+    /// WRITTEN if the table does not hold it yet. `None` for an empty URI or
+    /// when Lexbor could not intern it.
+    ///
+    /// A built-in namespace is its static id only for its exact URI; any other
+    /// URI gets an entry of its own, keyed case-sensitively - what
+    /// `lxb_ns_append` makes, but without its case folding. A URI equal to one
+    /// Lexbor interned lower-cased (all its entries are) finds that entry, so
+    /// the two kinds share one table without colliding.
     pub fn intern_ns(self, uri: &[u8]) -> Option<NsId> {
+        if let Some(id) = self.lookup_ns(uri) {
+            return Some(id);
+        }
         if uri.is_empty() {
             return None;
         }
         // SAFETY: a live document; Lexbor copies the URI into its own table,
-        // which keeps the entry for the document's lifetime.
+        // which keeps the entry for the document's lifetime, and the table was
+        // made with `lxb_ns_data_t` entries (`lxb_dom_document_init`).
         let id = unsafe {
             let table = (*self.as_raw()).ns;
             if table.is_null() {
                 return None;
             }
-            let d = lxb::lxb_ns_append(table, uri.as_ptr(), uri.len());
-            if d.is_null() {
+            let d = lxb::lexbor_hash_insert(
+                table,
+                lxb::lexbor_hash_insert_raw,
+                uri.as_ptr(),
+                uri.len(),
+            ) as *mut lxb::lxb_ns_data_t;
+            /* The same guard `lxb_ns_append` applies: an id must lie past the
+             * static range, which a real allocation always does. */
+            if (d as usize) <= lxb::lxb_ns_id_enum_t_LXB_NS__LAST_ENTRY as usize {
                 return None;
             }
+            (*d).ns_id = d as usize;
             (*d).ns_id
         };
         NsId::from_raw(id)

data/lib/makiri/version.rb

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

data/script/check_unsafe_boundaries.rb

@@ -55,9 +55,9 @@ UNSAFE_ISLANDS = {
   "lexbor/abi.rs" => 4,
   "lexbor/adapter/arena_bytes.rs" => 14,
   "lexbor/adapter/cross_import.rs" => 2,
-  "lexbor/adapter/html/attrs.rs" => 20,
-  "lexbor/adapter/html/build.rs" => 24,
-  "lexbor/adapter/html/mod.rs" => 62,
+  "lexbor/adapter/html/attrs.rs" => 23,
+  "lexbor/adapter/html/build.rs" => 25,
+  "lexbor/adapter/html/mod.rs" => 63,
   "lexbor/adapter/html/mutate.rs" => 9,
   "lexbor/adapter/html/serialize.rs" => 18,
   "lexbor/adapter/post_parse.rs" => 13,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: makiri
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.13.0
 platform: ruby
 authors:
 - takahashim