makiri 0.11.0.rc1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7421d59a83c782fab157fb3b220761908b885190db8405dd5173ddaeb7343e83
-  data.tar.gz: 4f64149f513b8a8f5288da9158c6dd5fa673e79ca33f5acc2c06a863d6f46641
+  metadata.gz: 9c12838a29d87a6bd9acb72b97e1e25dbdfbdaff37e38609cce6fd562e0f76d7
+  data.tar.gz: f4531547107db81c7db834d6c991adcf68b8a0d2fd714e158d69b164140a18bc
 SHA512:
-  metadata.gz: b1da6427faed2ac5e96ff02c6eeeb207c999eee5322c8b65e63b95e6038dee2ffbcaa457580f2980b73de6a9d7436e8e602134e7a3bb5e0e5fc399072b6eddaf
-  data.tar.gz: 4ee2def4dbe0cc740450bfa2e0d8a448a7908f1356f6de877d2c91f1d7e58aa92d022fd9f553b55463e6e444875f0889f567102c2883ece072f886a93eb06a44
+  metadata.gz: fcdb5e1656c3ab6781c1bae97919b5ce65c5cbaa2bc3a0429a9088483f45407715e060afb2b6478d5ecb8a2d7495c319e3db54acd17f419c728d181a2b9becb4
+  data.tar.gz: 784ef5eaac9439e44ea99903544bcefac25869f18dc6312f0629669465f92a8f306f72b1bb62d5671babccfca2374f19c026dbb0da2a4f859f917c9822093b9b

data/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [0.11.0] - 2026-09-30
+
+No code changes since 0.11.0.rc2. Coming from 0.10.x, read the rc2 and rc1
+notes below as well.
+
+## [0.11.0.rc2] - 2026-09-30
+
+### Added
+
+* `Makiri::HTML::Document#create_element_ns(namespace_uri, qualified_name)`
+  (DOM `createElementNS`). An SVG or MathML element made this way keeps its
+  name's case and behaves like a parsed one. An upper-case name in the HTML
+  namespace that names a known element (`BR`, `DIV`) raises `Makiri::Error`.
+* `Makiri::XML::Element#set_loose_dom_attribute(qualified_name, value)` (DOM
+  `setAttribute`): the attribute is in no namespace and keeps the name as
+  given (`xmlns`, `xlink:href`, `v-on:click`). `to_xml` raises while the
+  document holds one XML cannot write.
+
+### Changed
+
+* A NUL in an element, attribute, doctype or PI target name raises
+  `ArgumentError`, like any other invalid name. A namespace that does not fit
+  the name still raises `Makiri::Error`.
+* HTML type selectors are case-sensitive on SVG and MathML elements, as in
+  browsers: `fegaussianblur` no longer matches `feGaussianBlur`.
+* `set_attribute_ns` accepts the XML namespace with any prefix or none again
+  (rc1 raised); `to_xml` writes such an attribute as `xml:name`.
+* XML `set_attribute_ns` accepts a namespace declaration XML forbids, such as
+  `xmlns:foo=""`. It binds nothing, and `to_xml` raises while it is present.
+* XML `create_document_type` accepts any public and system id, and any name
+  without whitespace, NUL or `>`. `to_xml` raises if the doctype cannot be
+  written as XML.
+
+### Fixed
+
+* `import_node` from XML to HTML keeps an upper-case XHTML element name
+  (`Foo`) instead of lower-casing it, and raises for one that names a known
+  element (`BR`).
+
 ## [0.11.0.rc1] - 2026-09-29
 
 ### Changed

data/NOKOGIRI_DIFFERENCES.md

@@ -107,6 +107,19 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
     invents one (`ns1`, `ns2`, ...) rather than shadow the other, as browsers do.
   * An element in no namespace stays that way under a default namespace,
     serialized as `xmlns=""`.
+  * `create_document_type` takes what the DOM's `createDocumentType` takes -
+    any id, and a name without whitespace, NUL or `>` - and `to_xml` refuses a
+    doctype XML cannot write (`create_document_type("q", "abcde", %(x"'y))`).
+    Nokogiri writes that system id as `"x"'y"`, which parses but reads
+    back as the id `x"'y` - a literal expands no references.
+  * `set_attribute_ns(XMLNS_NS, "xmlns:foo", "")` - a declaration Namespaces in
+    XML forbids, which the DOM's `setAttributeNS` accepts - is kept as an
+    attribute that binds nothing, and `to_xml` refuses the tree while it is
+    there. `root["xmlns:foo"] = ""` still raises.
+  * An attribute in the XML namespace is written as `xml:local`, whatever
+    prefix it was given (`set_attribute_ns(XML_NS, "a:bb")`, as the DOM
+    allows): Namespaces in XML binds that namespace to `xml` alone. It re-reads
+    to the same namespace and local name. `canonicalize` writes it so too.
   * Nodes from the factories (`create_element` and friends) still take their
     namespace from the context they are first inserted into, so a subtree can be
     built detached and attached afterwards. Only later moves carry.
@@ -165,7 +178,17 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
     The names HTML actually uses (`data-*`, `aria-*`, `@click`, `:href`,
     `v-on:x`, custom elements) are accepted.
   * `set_attribute_ns(nil, "x:y")` raises, as the DOM's `setAttributeNS` does:
-    a prefix needs a namespace.
+    a prefix needs a namespace. `[]=` (HTML) and `set_loose_dom_attribute`
+    (XML) are the DOM's `setAttribute`, which makes such an attribute.
+  * A refused name raises `ArgumentError` - a NUL in it too - and a namespace
+    that does not fit the name (`set_attribute_ns`, `create_element_ns`)
+    raises `Makiri::Error`. Invalid UTF-8 raises `Makiri::Error` for every
+    argument, names included.
+  * `create_element_ns` refuses an HTML-namespace name in upper case that
+    lower-cases to an element Lexbor knows (`BR`, `DIV`), where the DOM makes
+    an unknown element: Lexbor would make that element (`BR` void, its
+    children never written). Other names keep their case (`MY-EL`). Nokogiri
+    has no `create_element_ns`.
 * An HTML `<template>` follows the WHATWG content model, which Nokogiri does
   not: its parsed contents live in the separate fragment `Element#content_fragment`
   returns, `template.children` is empty, and `inner_html` / `inner_html=`
@@ -257,8 +280,15 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   .matches?("p")` is true, on both representations). Nokogiri raises
   `NoMethodError` there - it implements `#matches?` as a search from
   `ancestors.last`, which a detached node does not have.
-* * Type selectors are ASCII case-insensitive (CSS-correct for HTML; `LI` matches `<li>`)
-  * `Nokogiri::HTML5` is case-sensitive there.
+* Type selectors in an HTML document follow the HTML Standard's
+  case-sensitivity rule, as browsers do: lower-cased for an HTML element (`LI`
+  matches `<li>`), as written for any other (`feGaussianBlur` matches the SVG
+  element, `fegaussianblur` does not). An HTML element named in upper case
+  (`create_element_ns(XHTML, "MY-EL")`, which keeps its name as the DOM does)
+  therefore matches no type selector.
+  * `Nokogiri::HTML5` is case-sensitive on HTML elements too, so `LI` does not
+    match `<li>` there. `Makiri::XML`'s `#css` is case-sensitive, as XML names
+    are.
 
 ## Serialization
 
@@ -285,7 +315,10 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   and attribute values (`[]=`, `set_attribute_ns`) - and stored/read back
   verbatim, matching the WHATWG DOM / browsers (`document.createTextNode("\0")`).
   It is still rejected in names, tag names, namespaces, PI target/data, CSS
-  selectors, and XPath expressions/variable names (a NUL there raises).
+  selectors, and XPath expressions/variable names. A NUL in a name given to a
+  factory or setter (element, attribute, doctype and PI target names) raises
+  `ArgumentError`, as any other refused name does; anywhere else it raises
+  `Makiri::Error`.
   * On re-parse, the HTML tokenizer replaces a U+0000 in text/attributes with
     U+FFFD (WHATWG), so a serialized-then-reparsed round-trip is not byte-identical.
   * `Makiri::XML` rejects NUL everywhere: XML 1.0 has no legal U+0000 character,

data/ext/makiri/rust/build.rs

@@ -267,7 +267,6 @@ fn main() {
         .allowlist_function("lxb_dom_document_create_processing_instruction")
         .allowlist_function("lxb_dom_document_create_document_fragment")
         .allowlist_function("lxb_dom_document_type_create")
-        .allowlist_function("lxb_dom_document_type_valid_name")
         .allowlist_function("lxb_dom_document_import_node")
         .allowlist_function("lexbor_str_init")
         .allowlist_function("lxb_html_document_destroy")

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

@@ -563,6 +563,24 @@ pub fn create_element<'d>(doc: HtmlDoc<'d>, name: &RubyText) -> Option<RawNode>
     doc.create_element(name.as_bytes()).map(RawNode::from)
 }
 
+/// The refusal of an HTML-namespace name Lexbor would make as another element
+/// (`HtmlDoc::misreads_html_name`), from `create_element_ns` and the
+/// XML-to-HTML import alike.
+pub const HTML_NAME_CASE: &str = "cannot make an HTML element whose upper-case name \
+lower-cases to a known element (BR, SCRIPT, ...): it would be made as that element";
+
+/// A new element named `local` in namespace `ns` ("" = none), with `prefix`
+/// ("" = none) - the DOM's createElementNS, once the caller has validated and
+/// split the name.
+pub fn create_element_ns<'d>(
+    doc: HtmlDoc<'d>,
+    local: &[u8],
+    ns: &[u8],
+    prefix: &[u8],
+) -> Option<RawNode> {
+    doc.create_element_ns(local, ns, prefix).map(RawNode::from)
+}
+
 /// A new Text node in `doc`.
 pub fn create_text(doc: HtmlDoc<'_>, text: &RubyData) -> Option<RawNode> {
     doc.create_text(text.as_bytes()).map(RawNode::from)

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

@@ -435,9 +435,41 @@ pub fn namespace_arg(in_: Value, what: &str) -> Result<Option<RubyText>, Error>
 /// Coerce to a String and enforce the strict contract (valid UTF-8, no NUL),
 /// naming `what` in the error. The names-and-engine-input path.
 pub fn ruby_verified_text(in_: Value, what: &str) -> Result<RubyText, Error> {
+    verified_text_raising(in_, what, makiri_error)
+}
+
+/// [`ruby_verified_text`] for a NAME given to a factory or a setter: the same
+/// contract, but a NUL raises `ArgumentError` - the DOM's
+/// InvalidCharacterError, which is what every other character a naming rule
+/// refuses raises. It raised `Makiri::Error` from here, before any naming rule
+/// ran, so a caller translating `ArgumentError` into a DOMException let that
+/// one through. Invalid UTF-8 stays `Makiri::Error`: it breaks the String
+/// contract every input shares, not a naming rule.
+pub fn ruby_verified_name(in_: Value, what: &str) -> Result<RubyText, Error> {
+    verified_text_raising(in_, what, crate::bridge::ruby::arg_error)
+}
+
+/// The one acquisition behind [`ruby_verified_text`] and
+/// [`ruby_verified_name`], which differ only in what a NUL raises: `on_nul`
+/// is handed the message. Everything else - invalid UTF-8, a copy that ran out
+/// of memory, a raise while locking - is answered the same way for both.
+fn verified_text_raising(
+    in_: Value,
+    what: &str,
+    on_nul: fn(String) -> Error,
+) -> Result<RubyText, Error> {
+    use crate::cutf8::TextVerdict;
     let s = string_of(in_)?;
-    RubyText::acquire(s, |s, b| text_check(s, b).problem()).map_err(|r| match r {
-        Refusal::Check(problem) => text_error(what, problem),
+    RubyText::acquire(s, |s, b| {
+        let v = text_check(s, b);
+        (v != TextVerdict::Ok).then_some(v)
+    })
+    .map_err(|r| match r {
+        Refusal::Check(TextVerdict::HasNul) => on_nul(format!(
+            "{what} {}",
+            TextVerdict::HasNul.problem().unwrap_or_default()
+        )),
+        Refusal::Check(v) => text_error(what, v.problem().unwrap_or_default()),
         Refusal::Oom => oom_reading(),
         Refusal::Raised(e) => e,
     })

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

@@ -208,6 +208,7 @@ fn xml_mut_error(st: MutError) -> Error {
         MutError::BadName => {
             return crate::bridge::ruby::arg_error("not a well-formed XML name");
         }
+        MutError::BadDomName(why) => return crate::bridge::ruby::arg_error(why),
         MutError::BadChars => "value contains a character or sequence not permitted in XML",
         MutError::UnboundNs => "namespace prefix is not bound in this scope",
         MutError::Type => "operation unsupported for this node type",
@@ -243,6 +244,7 @@ namespace (only xmlns=\"\" undeclares, and only the default)"
             "the namespace does not fit the qualified name (a prefix needs a namespace; \
 xml and xmlns take only their own)"
         }
+        MutError::HtmlNameCase => crate::bridge::html::HTML_NAME_CASE,
         MutError::Internal => "internal error mutating XML (no document)",
         /* The document's own budget, not the machine's memory - so the same
          * exception a parse raises for the same cause. */
@@ -358,13 +360,32 @@ pub fn begin_edit(this: XmlSelf) -> Result<Editing, Error> {
 /// A String argument verified as an engine string - valid UTF-8, no NUL - and
 /// short enough for an arena span (4 GiB).
 pub fn verified_text(v: Value, what: &str) -> Result<RubyText, Error> {
-    let t = ruby_verified_text(v, what)?;
+    fits_xml_node(ruby_verified_text(v, what)?)
+}
+
+/// `t`, unless it is too long for an XML node's `u32` span.
+fn fits_xml_node(t: RubyText) -> Result<RubyText, Error> {
     if u32::try_from(t.len()).is_err() {
         return Err(makiri_error("string too long for an XML node (max 4 GiB)"));
     }
     Ok(t)
 }
 
+/// [`verified_text`] for a name given to a factory or a setter: a NUL raises
+/// `ArgumentError`, as any other refused name does
+/// ([`crate::bridge::string::ruby_verified_name`]).
+pub fn verified_name(v: Value, what: &str) -> Result<RubyText, Error> {
+    fits_xml_node(crate::bridge::string::ruby_verified_name(v, what)?)
+}
+
+/// [`verified_name`] for an optional argument: `nil` is `None`.
+pub fn verified_name_opt(v: Value, what: &str) -> Result<Option<RubyText>, Error> {
+    if v.is_nil() {
+        return Ok(None);
+    }
+    verified_name(v, what).map(Some)
+}
+
 /// [`verified_text`] for an optional argument: `nil` is `None` - the same
 /// shape as `bridge::string::ruby_verified_text_opt`.
 pub fn verified_text_opt(v: Value, what: &str) -> Result<Option<RubyText>, Error> {

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

@@ -170,6 +170,7 @@ fn init_mutate() -> Result<(), Error> {
     m.define_method("content=", method!(mutate::set_content, 1))?;
 
     doc.define_method("create_element", method!(mutate::create_element, 1))?;
+    doc.define_method("create_element_ns", method!(mutate::create_element_ns, 2))?;
     doc.define_method(
         "create_document_type",
         method!(mutate::create_document_type, -1),

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

@@ -21,11 +21,11 @@ use crate::bridge::ruby::{makiri_error, string_of};
 use crate::bridge::fragment::{set_template_inner_html, stage_fragment_in};
 use crate::bridge::html::{edit, insert, owning_doc, wrap_html_node, HtmlEdit, HtmlSelf};
 use crate::bridge::string::{
-    namespace_arg, ruby_verified_data, ruby_verified_text, ruby_verified_text_opt,
+    namespace_arg, ruby_verified_data, ruby_verified_name, ruby_verified_text,
+    ruby_verified_text_opt,
 };
 use crate::lexbor::adapter::html::{HtmlElementMut, NodeType, Place, RawNode};
 use crate::xml::dom_name;
-use crate::xml::qname::Split;
 
 /// `name` held to the WHATWG DOM rule `ok`, else `ArgumentError` - the DOM's
 /// InvalidCharacterError, and what the XML side raises for a bad name.
@@ -49,6 +49,29 @@ fn check_dom_name(
     ))
 }
 
+/// The refusal of a namespace that does not fit the qualified name it came with.
+const NS_MISFIT: &str =
+    "the namespace does not fit the qualified name (a prefix needs a namespace; \
+xml and xmlns take only their own)";
+
+/// [`dom_name::validate_and_extract`] with its refusals as the method raises
+/// them: `ArgumentError` for a name, `Makiri::Error` for a namespace.
+fn extract<'q>(
+    ruby: &Ruby,
+    ns: &[u8],
+    qname: &'q crate::bridge::string::RubyText,
+    local_ok: fn(&[u8]) -> bool,
+    what: &str,
+) -> Result<(&'q [u8], &'q [u8]), Error> {
+    dom_name::validate_and_extract(ns, qname.as_bytes(), local_ok).map_err(|e| match e {
+        dom_name::ExtractError::Name => Error::new(
+            ruby.exception_arg_error(),
+            format!("invalid HTML {what} name"),
+        ),
+        dom_name::ExtractError::Namespace => makiri_error(NS_MISFIT),
+    })
+}
+
 /// 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.
@@ -116,7 +139,7 @@ pub fn aset(ruby: &Ruby, this: HtmlSelf, rb_name: Value, rb_value: Value) -> Res
         if edit.node_type() != NodeType::Element {
             return Err(makiri_error(REFUSAL));
         }
-        let nv = ruby_verified_text(rb_name, "attribute name")?;
+        let nv = ruby_verified_name(rb_name, "attribute name")?;
         let vv = ruby_verified_data(rb_value, "attribute value")?;
         check_dom_name(ruby, &nv, dom_name::valid_attribute_local_name, "attribute")?;
         let el = element_of(edit, REFUSAL)?;
@@ -140,40 +163,19 @@ pub fn set_attribute_ns(
         if edit.node_type() != NodeType::Element {
             return Err(makiri_error(REFUSAL));
         }
-        let qv = ruby_verified_text(rb_qname, "attribute qualified name")?;
+        let qv = ruby_verified_name(rb_qname, "attribute qualified name")?;
         let vv = ruby_verified_data(rb_value, "attribute value")?;
         let nv = namespace_arg(rb_ns, "namespace")?;
-        /* The DOM's "validate and extract": split at the first colon, check
-         * both halves, then that the namespace fits them - the rule XML's
-         * set_attribute_ns applies too (`xml::qname::ns_fits_name`). It named
-         * `(nil, "x:y")` a prefixed attribute in no namespace. */
-        let q = qv.as_bytes();
-        let colon = q.iter().position(|&b| b == b':');
-        let (prefix, local) = match colon {
-            Some(i) => (&q[..i], &q[i + 1..]),
-            None => (&b""[..], q),
-        };
-        let names_ok = dom_name::valid_attribute_local_name(local)
-            && (colon.is_none() || dom_name::valid_namespace_prefix(prefix));
-        check_dom_name(ruby, &qv, |_| names_ok, "attribute")?;
+        /* The DOM's "validate and extract". It named `(nil, "x:y")` a
+         * prefixed attribute in no namespace. */
         let ns = nv.as_ref().map_or(&b""[..], |n| n.as_bytes());
-        /* `Split` holds u32 lengths; a name past that would be split wrong, so
-         * it is refused rather than truncated (each `as u32` below is exact). */
-        if u32::try_from(q.len()).is_err() {
-            return Err(makiri_error(
-                "attribute qualified name too long (max 4 GiB)",
-            ));
-        }
-        let split = match colon {
-            Some(i) => Split::prefixed(i as u32, (q.len() - i - 1) as u32),
-            None => Split::unprefixed(q.len() as u32),
-        };
-        if !crate::xml::qname::ns_fits_name(ns, q, &split) {
-            return Err(makiri_error(
-                "the namespace does not fit the qualified name (a prefix needs a namespace; \
-xml and xmlns take only their own)",
-            ));
-        }
+        extract(
+            ruby,
+            ns,
+            &qv,
+            dom_name::valid_attribute_local_name,
+            "attribute",
+        )?;
         let el = element_of(edit, REFUSAL)?;
         crate::bridge::html::set_attribute_ns(el, nv.as_ref().map(|n| n.as_bytes()), &qv, &vv)
             .map_err(|_| makiri_error("failed to set namespaced attribute"))?;
@@ -304,7 +306,7 @@ fn created(node: Option<RawNode>, rb_self: Value, what: &str) -> Result<Value, E
 pub fn create_element(ruby: &Ruby, rb_self: Value, rb_name: Value) -> Result<Value, Error> {
     crate::bridge::ruby::entry(|| {
         let doc = owning_doc(&rb_self)?;
-        let nv = ruby_verified_text(rb_name, "element name")?;
+        let nv = ruby_verified_name(rb_name, "element name")?;
         check_dom_name(ruby, &nv, dom_name::valid_element_local_name, "element")?;
         created(
             crate::bridge::html::create_element(doc, &nv),
@@ -314,6 +316,37 @@ pub fn create_element(ruby: &Ruby, rb_self: Value, rb_name: Value) -> Result<Val
     })
 }
 
+/// `Document#create_element_ns(namespace_uri, qualified_name)` -> Element.
+///
+/// The DOM's createElementNS: the name is split at its first colon and each
+/// half held to the DOM's rule (`ArgumentError`), then the namespace to the
+/// name (`Makiri::Error`). Not `create_element`'s rule - `"0:a"` is prefix `0`
+/// and local name `a` - and the name keeps its case, as a parsed foreign
+/// element's does.
+pub fn create_element_ns(
+    ruby: &Ruby,
+    rb_self: Value,
+    rb_ns: Value,
+    rb_qname: Value,
+) -> Result<Value, Error> {
+    crate::bridge::ruby::entry(|| {
+        let doc = owning_doc(&rb_self)?;
+        let nv = namespace_arg(rb_ns, "namespace")?;
+        let qv = ruby_verified_name(rb_qname, "element qualified name")?;
+        let ns = nv.as_ref().map_or(&b""[..], |n| n.as_bytes());
+        let (prefix, local) =
+            extract(ruby, ns, &qv, dom_name::valid_element_local_name, "element")?;
+        if doc.misreads_html_name(local, ns) {
+            return Err(makiri_error(crate::bridge::html::HTML_NAME_CASE));
+        }
+        created(
+            crate::bridge::html::create_element_ns(doc, local, ns, prefix),
+            rb_self,
+            "element",
+        )
+    })
+}
+
 /// `Document#create_text_node(content)` -> Text.
 pub fn create_text_node(_ruby: &Ruby, rb_self: Value, rb_text: Value) -> Result<Value, Error> {
     crate::bridge::ruby::entry(|| {
@@ -349,7 +382,7 @@ pub fn create_pi(
 ) -> Result<Value, Error> {
     crate::bridge::ruby::entry(|| {
         let doc = owning_doc(&rb_self)?;
-        let tv = ruby_verified_text(rb_target, "processing instruction target")?;
+        let tv = ruby_verified_name(rb_target, "processing instruction target")?;
         let dv = ruby_verified_text(rb_data, "processing instruction data")?;
         /* DOM createProcessingInstruction: the target must match the XML Name
          * production. Lexbor leaves that check as a TODO, and an unchecked
@@ -383,7 +416,7 @@ pub fn create_document_type(ruby: &Ruby, rb_self: Value, args: &[Value]) -> Resu
         let (rb_pub, rb_sys_) = args.optional;
 
         let doc = owning_doc(&rb_self)?;
-        let nv = ruby_verified_text(rb_name, "doctype name")?;
+        let nv = ruby_verified_name(rb_name, "doctype name")?;
         if !crate::bridge::html::valid_doctype_name(&nv) {
             /* The caller's error, not Lexbor's, so the exception class is picked
              * here - the check itself is the DOM layer's. */

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

@@ -131,6 +131,10 @@ fn init_mutate() -> Result<(), Error> {
         m.define_method(name, method!(mutate::delete, 1))?;
     }
     m.define_method("set_attribute_ns", method!(mutate::set_attribute_ns, 3))?;
+    m.define_method(
+        "set_loose_dom_attribute",
+        method!(mutate::set_loose_dom_attribute, 2),
+    )?;
     m.define_method(
         "remove_attribute_ns",
         method!(mutate::remove_attribute_ns, 2),

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

@@ -16,8 +16,9 @@ use crate::bridge::ruby::makiri_error;
 use crate::bridge::string::namespace_arg;
 
 use crate::bridge::xml::{
-    begin_edit, import_copy, incoming_node, verified_text, verified_text_opt,
-    with_arena_for_new_node, wrap_xml_node as wrap, xml_mut_result, Editing, XmlSelf,
+    begin_edit, import_copy, incoming_node, verified_name, verified_name_opt, verified_text,
+    verified_text_opt, with_arena_for_new_node, wrap_xml_node as wrap, xml_mut_result, Editing,
+    XmlSelf,
 };
 use crate::init::CLASS_XML_DOCUMENT;
 use crate::xml::dom_name::split_loose_dom_name;
@@ -61,7 +62,7 @@ fn element_for(this: XmlSelf) -> Result<Editing, Error> {
 pub fn aset(_ruby: &Ruby, this: XmlSelf, name: Value, val: Value) -> Result<Value, Error> {
     crate::bridge::ruby::entry(|| {
         let edit = element_for(this)?;
-        let nv = verified_text(name, "attribute name")?;
+        let nv = verified_name(name, "attribute name")?;
         let vv = verified_text(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))?)?;
@@ -79,7 +80,7 @@ pub fn set_attribute_ns(
 ) -> Result<Value, Error> {
     crate::bridge::ruby::entry(|| {
         let edit = element_for(this)?;
-        let qv = verified_text(qname, "attribute qualified name")?;
+        let qv = verified_name(qname, "attribute qualified name")?;
         let vv = verified_text(val, "attribute value")?;
         let nv = namespace_arg(ns, "namespace")?;
         let (ns, qname, value) = (
@@ -92,6 +93,29 @@ pub fn set_attribute_ns(
     })
 }
 
+/// `element.set_loose_dom_attribute(qualified_name, value)` -> value.
+///
+/// The DOM's `setAttribute` for a caller building a browser's tree over XML -
+/// `create_loose_dom_element`'s counterpart: the name is not split, and a new
+/// attribute is in no namespace. `ArgumentError` for a name the DOM refuses.
+pub fn set_loose_dom_attribute(
+    _ruby: &Ruby,
+    this: XmlSelf,
+    name: Value,
+    val: Value,
+) -> Result<Value, Error> {
+    crate::bridge::ruby::entry(|| {
+        let edit = element_for(this)?;
+        let nv = verified_name(name, "attribute name")?;
+        let vv = verified_text(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))?,
+        )?;
+        Ok(val)
+    })
+}
+
 /// `element.remove_attribute_ns(namespace_or_nil, local_name)` -> self.
 pub fn remove_attribute_ns(
     _ruby: &Ruby,
@@ -223,7 +247,7 @@ pub fn create_element(ruby: &Ruby, rb_self: Value, args: &[Value]) -> Result<Val
             }
         }
 
-        let nv = verified_text(name, "element name")?;
+        let nv = verified_name(name, "element name")?;
         let cv = verified_text_opt(content, "element content")?;
         let name = nv.as_bytes();
         let el = xml_mut_result(with_arena_for_new_node(rb_self, |d| {
@@ -267,9 +291,9 @@ pub fn create_loose_dom_element(
     ns: Value,
 ) -> Result<Value, Error> {
     crate::bridge::ruby::entry(|| {
-        let qv = verified_text(qname, "qualified name")?;
-        let lv = verified_text(local, "local name")?;
-        let pv = verified_text_opt(prefix, "prefix")?;
+        let qv = verified_name(qname, "qualified name")?;
+        let lv = verified_name(local, "local name")?;
+        let pv = verified_name_opt(prefix, "prefix")?;
         let nv = namespace_arg(ns, "namespace URI")?;
 
         let qname = qv.as_bytes();
@@ -296,7 +320,7 @@ pub fn create_document_type(ruby: &Ruby, rb_self: Value, args: &[Value]) -> Resu
         >(args)?;
         let name = a.required.0;
         let nil = ruby.qnil().as_value();
-        let nv = verified_text(name, "doctype name")?;
+        let nv = verified_name(name, "doctype name")?;
         let pv = verified_text_opt(a.optional.0.unwrap_or(nil), "doctype public id")?;
         let sv = verified_text_opt(a.optional.1.unwrap_or(nil), "doctype system id")?;
         /* An empty id is absent, like nil, matching the HTML factory and Nokogiri. */
@@ -342,7 +366,7 @@ pub fn create_cdata(_ruby: &Ruby, rb_self: Value, t: Value) -> Result<Value, Err
 
 pub fn create_pi(_ruby: &Ruby, rb_self: Value, target: Value, data: Value) -> Result<Value, Error> {
     crate::bridge::ruby::entry(|| {
-        let tg = verified_text(target, "PI target")?;
+        let tg = verified_name(target, "PI target")?;
         let dt = verified_text(data, "PI data")?;
         let (target, data) = (tg.as_bytes(), dt.as_bytes());
         let pi = xml_mut_result(with_arena_for_new_node(rb_self, |d| {

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

@@ -43,7 +43,7 @@ fn declarations(d: &XmlDoc, id: NodeId) -> impl Iterator<Item = (NodeId, &[u8],
         .into_iter()
         .flatten()
         .filter_map(move |a| {
-            let p = crate::xml::qname::xmlns_prefix(d.qname(a))?;
+            let p = d.decl_prefix(a)?;
             Some((a, p, d.value(a)))
         })
 }

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

@@ -32,7 +32,21 @@ fn to_xml_opts(ruby: &Ruby, args: &[Value]) -> Result<(i32, Value), Error> {
 /// A serialization failure as `Makiri::Error`, worded for `verb`.
 fn failure_error(f: Failure, verb: &str) -> Error {
     let msg = match f {
-        Failure::DomLooseName => format!("cannot {verb} XML containing a DOM-loose element name"),
+        Failure::DomLooseName => {
+            format!("cannot {verb} XML containing a DOM-loose element name")
+        }
+        Failure::DomLooseDoctype => {
+            format!(
+                "cannot {verb} XML containing a DOM-loose doctype (a name or id XML cannot write)"
+            )
+        }
+        Failure::ForbiddenDeclaration => format!(
+            "cannot {verb} XML containing a namespace declaration XML forbids \
+(such as xmlns:p=\"\", held as set_attribute_ns made it)"
+        ),
+        Failure::DomLooseAttributeName => {
+            format!("cannot {verb} XML containing a DOM-loose attribute name")
+        }
         Failure::PiTargetColon => {
             format!("cannot {verb} XML containing a processing-instruction target with a colon")
         }

data/ext/makiri/rust/src/lexbor/adapter/cross_import.rs

@@ -21,7 +21,8 @@
 
 use crate::falloc::{try_vec_with_capacity, OomOption, OomResult, VecPush};
 use crate::lexbor::adapter::html::{
-    BuildingElement, BuildingNode, HtmlDoc, HtmlElement, HtmlNode, NsId, RawDoc, RawNode,
+    has_ascii_uppercase, BuildingElement, BuildingNode, HtmlDoc, HtmlElement, HtmlNode, NsId,
+    RawDoc, RawNode,
 };
 use crate::xml::model::{ArenaKind, Document as XmlDoc, MutError, NodeId};
 use crate::xml::mutate;
@@ -124,11 +125,14 @@ fn h2x_copy_attrs(doc: &mut XmlDoc, s: HtmlElement<'_>, el: NodeId) -> Result<()
              * restate one, or move one: `<svg><g xmlns="urn:evil">` put `g`
              * and its children in `urn:evil`. */
             (Some(NsId::XMLNS), _) | (_, Some(_)) => {}
-            /* An attribute in the XML namespace is always named `xml:`: the
-             * parser's foreign-attribute table gives it that prefix, and
-             * `set_attribute_ns` refuses the XML namespace under any other
-             * name (`ns_fits_name`), so `set_attribute` resolves it back. */
-            (None | Some(NsId::XML), _) => {
+            /* An attribute in the XML namespace crosses WITH it: the DOM's
+             * setAttributeNS gives it any prefix or none (`lang`, `p:lang`),
+             * so its name alone does not say so, and the XML serializer
+             * writes it as `xml:` whatever it is called. */
+            (Some(NsId::XML), _) => {
+                mutate::set_attribute_ns(doc, el, crate::xml::XML_NS_URI, name, value)?;
+            }
+            (None, _) => {
                 let colon = name.iter().position(|&b| b == b':');
                 match colon {
                     Some(c) if &name[..c] != b"xml" => return Err(no_namespace_colon(name)),
@@ -369,13 +373,23 @@ fn x2h_make<'doc>(
              * with its prefix, so the copy's localName is `e` and not `p:e`
              * (as `//q:e` and local-name() read it), and with its case, so an
              * SVG `linearGradient` does not come back `lineargradient`. An
-             * XHTML element is an HTML element, whose name is lower case. */
+             * XHTML element named in lower case is the HTML element of that
+             * name. One with upper case is not: it goes the createElementNS
+             * way too, keeping its case (`Foo`, where lower-casing it renamed
+             * it `foo`) - or refused when Lexbor would make it as a known
+             * element (`BR` came out the void `br`, its children gone). */
             let (prefix, ns) = (doc.prefix(s), doc.ns(s));
-            let el = if prefix.is_empty() && hdoc.lookup_ns(ns) == Some(NsId::HTML) {
+            let el = if prefix.is_empty()
+                && !has_ascii_uppercase(doc.local(s))
+                && hdoc.lookup_ns(ns) == Some(NsId::HTML)
+            {
                 let el = hdoc.create_element(doc.qname(s)).or_oom::<MutError>()?;
                 el.set_ns(NsId::HTML);
                 el
             } else {
+                if hdoc.misreads_html_name(doc.local(s), ns) {
+                    return Err(MutError::HtmlNameCase);
+                }
                 hdoc.create_element_ns(doc.local(s), ns, prefix)
                     .or_oom::<MutError>()?
             };