makiri 0.11.0.rc1-aarch64-linux → 0.12.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0113842390b011ad47e3dabe52b53130f484abefa354932c43b5f33d9c52ab85'
-  data.tar.gz: 4dfe81ec97b69973cbc0a5ae1124867fa79aabfe4788555ea2763bed23719449
+  metadata.gz: '080648651b5e8e38a405373a252b0ded69f1e5a672c6e5031e0f31058b09fa80'
+  data.tar.gz: c13624a3a5ed5e94e4d0adc761280e498fbf3e34891ba41d46cfeeed762bcf68
 SHA512:
-  metadata.gz: d309e7a41fc3394688cf0f8fd1f3cecb84e30224261f9e251374851cee56436bab0b1c3e0fd7179f5174890b2f28230b75cebcfac9050c27e90af1f6bdf56a1a
-  data.tar.gz: 3292ff153f15657ba6dd75945bcaf7ccccdc354da2861f23a848bab9f3a2de1ad129198248f030671aead26422e74d0c9fd268da81a13f7e41f7822dddb70d6a
+  metadata.gz: ba444c67f4c84cbe0d3a9317ddcfbbf6854daf1c9fa0a020e16e319ac9d8e98e693fa0b245ba8f3abb3bf9e0f7837af77238c7c0d4557d9d268d1b0465bd24cd
+  data.tar.gz: c822e0c488221872b85fc6d8390dea3ee1b72def3c35ae160750102a26115047a84ca0f06df2f0b3ee34b7b3dacc011edbb7c56de27cff93e96fb7e9f9132360

data/CHANGELOG.md

@@ -1,5 +1,86 @@
 # Changelog
 
+## [0.12.0] - 2026-10-01
+
+Most changes accept what the DOM allows where 0.11.0 raised. The XML
+serializers (`to_xml`, `canonicalize`) raise instead when the tree holds
+something XML cannot write.
+
+### Changed
+
+HTML:
+
+* `to_html` / `inner_html` write a `<template>`'s contents, not its own
+  children (added with `add_child`), as browsers do.
+* `create_element_ns` in the HTML namespace accepts an upper-case name
+  (`BR`, `DIV`), as the DOM does. It makes an unknown element: not void, and
+  not matched by type selectors. Importing such an XHTML element from XML
+  behaves the same way.
+
+XML:
+
+* Text, attribute values and comments accept the characters the DOM allows:
+  `"\f"`, U+0001, NUL, and `--` in a comment.
+* `set_attribute_ns` accepts names XML cannot write, such as `p:a}b`.
+* `to_xml` and `canonicalize` raise while any of the above is in the tree.
+* `create_cdata` with `]]>` and `create_processing_instruction` with `?>`
+  now raise `ArgumentError`.
+* `canonicalize` adds the namespace declarations a name needs instead of
+  raising. It still raises where it would have to invent a prefix.
+
+HTML to XML (`import_node`):
+
+* The copy is in its namespace at once. Before, it was in none until
+  inserted.
+* The copy gets no `xmlns` attribute.
+* An attribute XML cannot write (`x-on:click`, `@click`) is copied as it is
+  instead of raising.
+* A `<template>` keeps its own children, after its contents.
+
+Other:
+
+* `Node#path` round-trips when a sibling with a different prefix or case
+  would also match the same XPath step.
+
+## [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` keeps the case of an HTML-namespace name, as the DOM
+    does: `create_element_ns(XHTML, "BR")` is an unknown element named `BR`,
+    not a void `br`, and type selectors do not match it (XPath name tests do,
+    folding case on HTML elements as browsers do). 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=`
@@ -175,6 +198,11 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   ordinary element, with the parsed nodes as its children, so
   `template.inner_html` and `template.children` answer the other way round and
   there is no `content_fragment`.
+  * `Makiri::XML` has no template contents: an XHTML `<template>`'s children
+    are its children. Crossing into HTML they become its contents, and back
+    they become children - what a browser's XML parser, which puts them in the
+    contents, and its importNode give for the same document. An XML
+    `<template>` whose children should stay children has no way to say so.
 * An HTML document has one root element and no text child, as the DOM requires;
   `doc << element` beside an existing root raises.
 * An insertion the DOM refuses - a child under a text, comment, PI, doctype
@@ -182,13 +210,20 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   `Makiri::Error` in both representations. Nokogiri refuses the same ones with
   `ArgumentError` (or `RuntimeError` for a second XML root).
 * Moving HTML into an XML document (`xml_doc.import_node(html_node)`, or
-  inserting one) keeps every name's namespace, and refuses what XML cannot
-  write that way. An attribute in no namespace whose name has a prefix other
-  than `xml` - `v-on:click`, `fb:like`, an `xlink:href` on an HTML (not SVG)
-  element - raises `Makiri::Error`: as XML it would be a prefix bound to
-  nothing. Nokogiri copies it and writes `v-on:click="..."` into output that is
-  not namespace-well-formed. An element named with a colon (`<fb:like>`)
-  crosses as a DOM-loose name, which `to_xml` refuses.
+  inserting one) copies it as the DOM's clone does: every element in its
+  namespace from the start (an imported `<p>` is XHTML before it is
+  inserted), every attribute named as it is, and no `xmlns` attribute added -
+  `to_xml` and `canonicalize` write the declarations the output needs.
+  Nokogiri's copy of an HTML5 `<div>` is in no namespace, and libxml2
+  declares `xmlns:svg` on it for an SVG child (in `namespace_definitions`),
+  writing the child as `<svg:svg>`. One XML cannot write that way -
+  in no namespace with a colon or no XML name, `v-on:click`, `:href`,
+  `@click`, `fb:like` - crosses DOM-loose, and `to_xml` refuses the tree
+  while it is there; so does an element named with a colon (`<fb:like>`).
+  Nokogiri copies them and writes output that is not namespace-well-formed.
+  * One exception to the DOM: an HTML attribute named `xml:lang` (in no
+    namespace) becomes the XML namespace's `xml:lang`, as the XML reader reads
+    that name, so XHTML-style HTML still writes as XML.
 * A known gap, in Lexbor's tag table: an HTML document that already holds a
   parsed element named with a colon (`<x:y>`, one local name) and then
   receives, by `import_node` from another document, a prefixed element
@@ -257,8 +292,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, "DIV")`, 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,8 +327,18 @@ 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,
-    so admitting it would produce non-well-formed XML.
+  * `Makiri::XML` holds the character data the DOM holds, NUL included:
+    text or an attribute value with a character XML has no `Char` for (`\f`,
+    U+0001, U+0000), a comment with `--`. Nokogiri takes the same, but NUL
+    (`ArgumentError`, a Ruby C-string limit). Where they part is the output. `to_xml` / `canonicalize` raise for such a tree; Nokogiri writes
+    `\f` in text as U+FFFD (the data changes) and a comment's `--` or an
+    attribute value's `\f` as it stands (the output does not parse).
+    `create_cdata` refuses `]]>` and `create_processing_instruction` `?>`,
+    raising `ArgumentError` as the DOM's factories do; Nokogiri takes the PI
+    and writes `<?t a?>b?>`, which re-reads as another tree.

data/lib/makiri/element.rb

@@ -22,5 +22,21 @@ module Makiri
     def path_step
       name_step("", unprefixed_element_namespace)
     end
+
+    # See {NodePath#path}. An element step selects by expanded name, not by the
+    # string of the test: `*[local-name()='BR' and ...]`, written for `h:BR`,
+    # also selects the unprefixed `BR` beside it. A bare name test on an HTML
+    # element folds ASCII case, as the engine (and browsers) match it, so `div`
+    # also selects the `DIV` createElementNS makes. Compared as strings, each
+    # pair was counted apart, and the path found the other one first.
+    def path_selects?(other, test)
+      return false unless other.element? && other.namespace_uri.to_s == namespace_uri.to_s
+
+      mine = local_name
+      theirs = other.local_name
+      return mine == theirs unless test == name && unprefixed_element_namespace
+
+      mine.downcase(:ascii) == theirs.downcase(:ascii)
+    end
   end
 end

data/lib/makiri/node_path.rb

@@ -48,7 +48,7 @@ module Makiri
       parent_node = parent
       return test unless parent_node # a detached top: #path answers "?" anyway
 
-      siblings = parent_node.children.select { |c| c.path_node_test == test }
+      siblings = parent_node.children.select { |c| path_selects?(c, test) }
       return test if siblings.length <= 1
 
       "#{test}[#{siblings.index(self) + 1}]"
@@ -73,6 +73,13 @@ module Makiri
       nil
     end
 
+    # Whether +test+, this node's own step, selects +other+, a sibling: the
+    # position counts exactly those. By default the tests are compared, which
+    # is the engine's answer for every kind but an element (see Element).
+    def path_selects?(other, test)
+      other.path_node_test == test
+    end
+
     # The name test for an element (+axis+ "") or attribute (+axis+ "@"): the
     # bare name when an unprefixed test reaches this node - it is in
     # +plain_namespace+ and its name is a plain NCName - else by expanded name.

data/lib/makiri/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Makiri
-  VERSION = "0.11.0.rc1"
+  VERSION = "0.12.0"
 end

data/script/check_alloc_failures.rb

@@ -142,7 +142,12 @@ SCENARIOS = {
     el = doc.create_element("made")
     el.add_child(doc.create_text_node("inner"))
     el["k"] = "v"
+    el.set_loose_dom_attribute("v-on:x", "1")
+    el.set_loose_dom_attribute("xmlns", "urn:loose")
+    el.set_loose_dom_attribute("k", "v2")
     doc.root.add_child(el)
+    el.remove_attribute_ns(nil, "v-on:x")
+    el.delete("xmlns")
     el.content = "rewritten"
     el.add_previous_sibling(doc.create_element("before"))
     el.add_next_sibling(doc.create_element("after"))
@@ -263,6 +268,7 @@ SCENARIOS = {
     d = Makiri::HTML::Document.parse("<html><body><div id='a'><p>one</p></div></body></html>")
     a = d.at_css("#a")
     a.add_child(d.create_element("made"))
+    a.add_child(d.create_element_ns("http://www.w3.org/2000/svg", "s:feBlend"))
     a.add_child(d.create_text_node("inner"))
     a.add_child(d.create_comment(" note "))
     a.add_child(d.create_processing_instruction("tgt", "pd"))

data/script/check_unsafe_boundaries.rb

@@ -59,6 +59,7 @@ UNSAFE_ISLANDS = {
   "lexbor/adapter/html/build.rs" => 19,
   "lexbor/adapter/html/mod.rs" => 60,
   "lexbor/adapter/html/mutate.rs" => 9,
+  "lexbor/adapter/html/serialize.rs" => 9,
   "lexbor/adapter/post_parse.rs" => 13,
   "lexbor/adapter/source_loc.rs" => 2,
   "lexbor/adapter/text_index.rs" => 1,
@@ -461,7 +462,7 @@ end
 # is generated, so its signature is Lexbor's. A new hand declaration of a
 # header-declared function belongs in build.rs's allowlist instead; one with no
 # header belongs in build.rs's UNDECLARED_EXPORTS as well as here.
-LEXBOR_HAND_DECLS = 3
+LEXBOR_HAND_DECLS = 4
 abi_decls = comments_removed(File.binread(File.join(RUST, "lexbor/abi.rs"))).scan(LEXBOR_DECL).length
 if abi_decls != LEXBOR_HAND_DECLS
   errors << "lexbor/abi.rs hand-declares #{abi_decls} Lexbor functions (expected " \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: makiri
 version: !ruby/object:Gem::Version
-  version: 0.11.0.rc1
+  version: 0.12.0
 platform: aarch64-linux
 authors:
 - takahashim