makiri 0.12.1-aarch64-linux → 0.14.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dad06ebaa7e4fa5fec68080e1714a5be6b72dc89172ff5f1f7840d6e73f4cffe
-  data.tar.gz: fe535f36f6d2f28acd4b3bd6c40f2d2f5c1a288affe5dc94ddd22d520c4e8ae7
+  metadata.gz: b3c3ed6ee3cd5fadbf71a4841bb984d84aa09b53ae9707da72ef2a4c5e6ce2c4
+  data.tar.gz: 3e92e200b9d198936e4ae65ee7f43bd0a2271827f3324c5127ea148a4b134b44
 SHA512:
-  metadata.gz: 444bfeb89cb88fe1e3bed19008401e0c8f09043e803722c4dac63c88063a53eaa8a9e097b08f5b11c25f83a76e4d5f7630d99846c4f1c9131feafb72351a17aa
-  data.tar.gz: c296890d6e35f332fb975542d2eebe5dd7b4283cbc3012715c43a37917aa82d40492136fe045ab44362e26572b09b3e1f9dc52b9f059d40d1fa93f3f25d5e11c
+  metadata.gz: dc3c6c844fce3e704a0560b5d07908b39082b6528ecf85fb77ea6e3d15c65cea1d7ff0cd99cd48fe52f96bf74ffed160f83cb3f233bf3e6e55de2923234124c4
+  data.tar.gz: 40b616cb7581a6b2afc5a03f6bdd3f66f7cec98eec398d19bf0121fcb011ff9e2e9f7412fb39976c0638590d9a263ef8ebdd7d285891a4e093142f94c6b097f5

data/CHANGELOG.md

@@ -1,5 +1,103 @@
 # Changelog
 
+## [0.14.0] - 2026-10-04
+
+### Added
+
+* `Document#attribute_version` (HTML and XML): an Integer that increases
+  whenever an attribute is added, removed or set (to the same value too),
+  including through an Attr node's `content=` or `remove`. Child-list and
+  text edits leave it as it is, so it can key a cache of attributes.
+* `Makiri::XML::Document#create_element_ns(namespace_uri, qualified_name)`,
+  like the HTML Document's and the DOM's `createElementNS`. The element keeps
+  its namespace wherever it is inserted; a name that is not an XML QName
+  (`f}oo`) makes an element that `to_xml` refuses.
+* `Makiri::HTML::Document.new`: an empty HTML document in no-quirks mode.
+* `Makiri::HTML::Document#quirks_mode?` and `#compat_mode` (`"BackCompat"` /
+  `"CSS1Compat"`, like the DOM's `compatMode`).
+* HTML `Attr#remove` / `#unlink` remove the attribute from its element, as on
+  XML. They raised "use delete(name) to remove an attribute".
+
+### Changed
+
+* `tree_version` counts child-list changes only. A Text, Comment, CDATA or
+  PI node's `content=` no longer moves it, and an HTML Attr node's
+  `content=` moves `attribute_version` instead.
+* `tree_version` and `attribute_version` are documented as cache keys: an
+  unchanged version means nothing it covers changed, while a changed one may
+  be conservative (an edit refused part-way can still move it).
+* `namespace_uri` and `prefix` are documented as `nil`, never `""`, when
+  there is no namespace or prefix, in HTML and XML.
+* `Document#dup` copies the tree node by node instead of re-parsing its
+  serialization. An HTML copy keeps a tree with no `<html>` root as it is and
+  keeps the quirks mode, and `Node#line` on it is `nil`. An XML copy keeps
+  every name and namespace as written (a re-parse invented `ns1:` prefixes),
+  copies data XML cannot write, and keeps the original's `max_bytes`.
+* XML `create_processing_instruction` accepts the target `xml` (in any case),
+  as the DOM does; `to_xml` and `canonicalize` refuse a tree holding one.
+* HTML `create_processing_instruction` raises `ArgumentError`, as XML does,
+  for data containing `?>`. It raised `Makiri::Error`.
+* A refused XML insertion names the DOM rule it breaks, in the same words as
+  HTML. It said "invalid placement".
+
+### Fixed
+
+* An Attr's `content=` and `remove` raise `FrozenError` when the element
+  that owns it is frozen, in HTML and XML.
+* XML `Attr#content=` sets the attribute's value. It raised "operation
+  unsupported".
+* HTML `title=` and `meta_encoding=` do nothing on a document with no
+  `<head>`, as the DOM's title setter does. They inserted the element directly
+  under the root element.
+* HTML `Document#root` and CSS `:root` return the document element, or `nil`.
+  Without an `<html>` element they returned the first child of any kind, such
+  as a comment, and `title=` raised on such a document.
+* An edit refused for its arguments - a frozen or non-node argument to an
+  HTML insertion, an invalid name given to XML `[]=`, `set_attribute_ns` or
+  `set_loose_dom_attribute`, a refused HTML `Attr#remove` - no longer moves a
+  version.
+* An XML copy that runs out of the document's byte budget (`import_node`,
+  `clone_node`, an insertion from another document) gives back what it used.
+  The document could not be edited any more after one.
+* Importing HTML into an XML document stores each namespace URI once instead
+  of once per element, which used up the byte budget faster.
+* An HTML Attr imported on its own from another HTML document keeps its
+  namespace URI as written. It was lower-cased.
+* `to_xml` and `canonicalize` write an element in the XML namespace as
+  `xml:local`. They wrote a declaration that does not parse. An element in
+  the XMLNS namespace is refused with `Makiri::Error`.
+* XML XPath: a prefixed attribute on a detached element, whose namespace is
+  not decided yet, no longer matches an unprefixed name test.
+* XML: references are read by one grammar everywhere. The internal subset
+  accepted a character reference to a character XML does not allow
+  (`<!ENTITY x "&#0;">`), and a malformed reference next to an entity
+  reference was reported as an unsupported DTD construct instead of as
+  malformed XML.
+
+## [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,33 @@ 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:)
 ```
 
+The limit covers the document's whole life, not only the parse: nodes and
+values made by editing it count too, and a replaced value or a removed node
+keeps its bytes until the document is gone. A document edited for a long time
+can be compacted with `dup`, which copies only what is in it now, under the
+same limit.
+
+### 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 +251,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/lib/makiri/html/document.rb

@@ -26,22 +26,37 @@ module Makiri
         _parse(String(source), max_tree_depth)
       end
 
-      # An independent copy of the whole document (like Nokogiri's Document#dup).
-      # Built by serialising and re-parsing, so the copy shares no nodes with the
-      # original - Node#dup's clone_node delegation is wrong for a document node,
-      # hence this override. (A DOM mutated into a shape the HTML parser would not
-      # itself produce, e.g. a foster-parented table cell, may be re-normalised on
-      # re-parse; a freshly parsed document round-trips unchanged.) Any level
-      # argument is ignored. #clone is this too (see {CloneViaDup}).
+      # An independent copy of the whole document (like Nokogiri's Document#dup):
+      # an empty document in the same quirks mode, given a deep copy of each of
+      # this one's children (+import_node+, which carries a <template>'s
+      # contents too), so the copy shares no nodes with the original and has
+      # the same tree - whatever shape it was built into, which a re-parse of
+      # +to_html+ would not keep (a Document.new without an <html> root gained
+      # the html/head/body shell and quirks mode). Node#dup's clone_node
+      # delegation is wrong for a document node, hence this override. Any
+      # level argument is ignored. #clone is this too (see {CloneViaDup}).
       #
-      # Node#line on the copy is the line in the SERIALISED text it was parsed
-      # from, not in the original source: `to_html` does not keep the original
-      # line breaks between tags, so the two differ.
-      #
-      # The re-parse has no tree-depth limit: the tree is already here, however
-      # it was built, and a copy must not fail where the original stands.
+      # Node#line is nil on the copy: its nodes were not parsed from a source.
       def dup(*)
-        self.class.parse(to_html, max_tree_depth: -1)
+        _empty_copy.tap do |copy|
+          children.each { |child| copy.add_child(copy.import_node(child, true)) }
+        end
+      end
+
+      # Whether the document is in quirks mode - the mode a missing or legacy
+      # doctype puts it in. Limited-quirks mode is not quirks mode here, as the
+      # DOM's +compatMode+ has it. (#quirks_mode is the raw value: 0 no-quirks,
+      # 1 quirks, 2 limited-quirks.)
+      # @return [Boolean]
+      def quirks_mode?
+        quirks_mode == 1
+      end
+
+      # The DOM's +document.compatMode+: "BackCompat" in quirks mode, else
+      # "CSS1Compat".
+      # @return [String]
+      def compat_mode
+        quirks_mode? ? "BackCompat" : "CSS1Compat"
       end
 
       # The document's <body> element, or nil.
@@ -56,11 +71,13 @@ module Makiri
         at_css("head")
       end
 
-      # Set the document title, creating <title> (in <head>) if absent.
+      # Set the document title, creating <title> (in <head>) if absent. A
+      # document with no <head> - a Document.new one before it has one - is
+      # left as it is, as the DOM's title setter leaves it.
       # @param text [String]
       # @return [String]
       def title=(text)
-        ensure_in_head("title", "title").content = text
+        ensure_in_head("title", "title")&.content = text
         text
       end
 
@@ -89,21 +106,28 @@ module Makiri
         nil
       end
 
-      # Set (or insert) a <meta charset> declaration.
+      # Set (or insert, in <head>) a <meta charset> declaration. Like #title=,
+      # it leaves a document with no <head> as it is.
       # @param value [String]
       # @return [String]
       def meta_encoding=(value)
-        ensure_in_head("meta[charset]", "meta")["charset"] = value
+        ensure_in_head("meta[charset]", "meta")&.[]=("charset", value)
         value
       end
 
       private
 
       # The first node matching +css_query+, or a freshly created <+tag+>
-      # appended to <head> (or the root when the document has no head). Shared by
-      # #title= and #meta_encoding=, which then set content / attributes on it.
+      # appended to <head>; nil when there is neither a match nor a head - never
+      # an element put straight under the root, which the DOM's title setter
+      # does not do either. Shared by #title= and #meta_encoding=, which then
+      # set content / attributes on it.
       def ensure_in_head(css_query, tag)
-        at_css(css_query) || Element.new(tag, self).tap { |el| (head || root).add_child(el) }
+        found = at_css(css_query)
+        return found if found
+
+        parent = head
+        parent && Element.new(tag, self).tap { |el| parent.add_child(el) }
       end
     end
   end

data/lib/makiri/version.rb

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

data/lib/makiri/xml/document.rb

@@ -20,25 +20,19 @@ module Makiri
         r ? r.replace(node) : add_child(node)
       end
 
-      # An independent copy of the whole document (like Nokogiri's
-      # Document#dup), sharing no nodes with the original. A document with a
-      # root is serialised and re-parsed, like {Makiri::HTML::Document#dup}. One
-      # without (still being built) is not well-formed, so it cannot be; what it
-      # can hold before a root - comments and processing instructions - is
-      # imported node by node instead. Any level argument is ignored, and
-      # #clone is this too (see {CloneViaDup}).
-      #
-      # The copy is parsed with the default +max_bytes+, not the original's, and
-      # its Node#line numbers are lines of the serialised text, which can
-      # differ from the original source's.
+      # An independent copy of the whole document (like Nokogiri's Document#dup),
+      # made node for node rather than by serialising and re-parsing: the
+      # top-level order, every name, namespace URI and namespace state,
+      # attributes, the doctype and character data are the original's. Nothing
+      # has to be writable as XML, no namespace is resolved again (a re-parse
+      # gave an attribute set in a namespace an invented `ns1:` prefix), and the
+      # copy keeps the original's +max_bytes+ budget and whether it declared an
+      # encoding. Any level argument is ignored, and #clone is this too (see
+      # {CloneViaDup}).
       #
       # @return [Makiri::XML::Document]
       def dup(*)
-        return self.class.parse(to_xml) if root
-
-        self.class.new.tap do |copy|
-          children.each { |child| copy.add_child(copy.import_node(child, true)) }
-        end
+        _copy
       end
     end
   end

data/script/check_unsafe_boundaries.rb

@@ -38,14 +38,14 @@ UNSAFE_ISLANDS = {
   "bridge/node_wrap.rs" => 1,
   "bridge/ruby.rs" => 18,
   "bridge/stack.rs" => 1,
-  "bridge/string.rs" => 29,
+  "bridge/string.rs" => 30,
   "bridge/typed.rs" => 21,
-  "bridge/wrapper.rs" => 19,
+  "bridge/wrapper.rs" => 20,
   "bridge/xml.rs" => 11,
-  "bridge/xml_decode.rs" => 7,
+  "bridge/xml_decode.rs" => 5,
   "bridge/xpath/context_object.rs" => 3,
   "bridge/xpath/handler.rs" => 7,
-  "bridge/xpath/mod.rs" => 5,
+  "bridge/xpath/mod.rs" => 7,
   "cbuf.rs" => 16,
   "cbuf/verify.rs" => 8,
   "falloc/cstr.rs" => 1,
@@ -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" => 25,
+  "lexbor/adapter/html/build.rs" => 26,
+  "lexbor/adapter/html/mod.rs" => 67,
   "lexbor/adapter/html/mutate.rs" => 9,
   "lexbor/adapter/html/serialize.rs" => 18,
   "lexbor/adapter/post_parse.rs" => 13,
@@ -73,7 +73,7 @@ UNSAFE_ISLANDS = {
   "lexbor/selector_cache.rs" => 15,
   "lexbor/selectors.rs" => 9,
   "lexbor/serialize.rs" => 2,
-  "lexbor/stylesheet.rs" => 7,
+  "lexbor/stylesheet.rs" => 8,
   "lexbor/tests.rs" => 16,
   "lexbor/xpath.rs" => 9,
   "token.rs" => 1,
@@ -90,36 +90,37 @@ UNSAFE_ISLANDS = {
 FORBID_ROOTS = %w[css/mod.rs glue/mod.rs lexbor/css_match/mod.rs xml/mod.rs xpath/mod.rs].freeze
 
 FORBID_FILES = %w[
-  css/build.rs css/lower.rs css/mod.rs
-  cutf8.rs cutf8/verify.rs dom_rules.rs
-  engine_error.rs falloc/verify.rs glue/css.rs
-  glue/html_doc.rs glue/html_node/css.rs glue/html_node/mutate.rs
-  glue/html_node/read.rs glue/html_node/serialize.rs glue/mod.rs
-  glue/node.rs glue/node_set.rs glue/query.rs
-  glue/xml_doc.rs glue/xml_node/css.rs glue/xml_node/mod.rs
-  glue/xml_node/mutate.rs glue/xml_node/ns.rs glue/xml_node/read.rs
-  glue/xml_node/serialize.rs glue/xml_node/strings.rs glue/xpath_context.rs
-  lexbor/adapter/dom_index.rs lexbor/contains_guard.rs lexbor/css_match/mod.rs
-  limits.rs node_type.rs ptr_table.rs
-  rust_tests.rs stack.rs text.rs
-  utf8_input.rs xml/arena.rs xml/attr_key.rs
-  xml/chars/expand.rs xml/chars/mod.rs xml/dom_name.rs
-  xml/encoding_sniff.rs xml/index.rs xml/mod.rs
-  xml/model.rs xml/mutate/attr.rs xml/mutate/copy.rs
-  xml/mutate/edit.rs xml/mutate/factory.rs xml/mutate/insert.rs
-  xml/mutate/mod.rs xml/mutate/ns.rs xml/qname.rs
-  xml/selftest.rs xml/serialize/bindings.rs xml/serialize/c14n.rs
-  xml/serialize/mod.rs xml/serialize/out.rs xml/serialize/xml.rs
-  xml/tree/cursor.rs xml/tree/decl.rs xml/tree/dtd.rs
-  xml/tree/mod.rs xml/tree/scope.rs xml/verify.rs
-  xml/xpath.rs xpath/abi.rs xpath/ast.rs
-  xpath/ast_ops.rs xpath/attr_pred.rs xpath/axis.rs
-  xpath/ctx.rs xpath/dom.rs xpath/eval.rs
-  xpath/funcs/ext.rs xpath/funcs/mod.rs xpath/lex.rs
-  xpath/limits.rs xpath/mod.rs xpath/nodetest.rs
-  xpath/number.rs xpath/order.rs xpath/parse.rs
-  xpath/step_index.rs xpath/str_cache.rs xpath/tests.rs
-  xpath/value.rs xpath/verify.rs
+  bridge/dom_error.rs css/build.rs css/lower.rs
+  css/mod.rs cutf8.rs cutf8/verify.rs
+  dom_rules.rs engine_error.rs falloc/verify.rs
+  glue/css.rs glue/html_doc.rs glue/html_node/css.rs
+  glue/html_node/mutate.rs glue/html_node/read.rs glue/html_node/serialize.rs
+  glue/mod.rs glue/node.rs glue/node_set.rs
+  glue/query.rs glue/xml_doc.rs glue/xml_node/css.rs
+  glue/xml_node/mod.rs glue/xml_node/mutate.rs glue/xml_node/ns.rs
+  glue/xml_node/read.rs glue/xml_node/serialize.rs glue/xml_node/strings.rs
+  glue/xpath_context.rs lexbor/adapter/dom_index.rs lexbor/contains_guard.rs
+  lexbor/css_match/mod.rs limits.rs node_type.rs
+  ptr_table.rs rust_tests.rs stack.rs
+  text.rs utf8_input.rs xml/arena.rs
+  xml/attr_key.rs xml/chars/expand.rs xml/chars/mod.rs
+  xml/dom_name.rs xml/encoding_sniff.rs xml/index.rs
+  xml/mod.rs xml/model.rs xml/mutate/attr.rs
+  xml/mutate/copy.rs xml/mutate/edit.rs xml/mutate/factory.rs
+  xml/mutate/insert.rs xml/mutate/mod.rs xml/mutate/ns.rs
+  xml/ns_scope.rs xml/qname.rs xml/selftest.rs
+  xml/serialize/bindings.rs xml/serialize/c14n.rs xml/serialize/mod.rs
+  xml/serialize/out.rs xml/serialize/xml.rs xml/tree/cursor.rs
+  xml/tree/decl.rs xml/tree/dtd.rs xml/tree/mod.rs
+  xml/tree/scope.rs xml/verify.rs xml/xpath.rs
+  xpath/abi.rs xpath/ast.rs xpath/ast_ops.rs
+  xpath/attr_pred.rs xpath/axis.rs xpath/ctx.rs
+  xpath/dom.rs xpath/eval.rs xpath/funcs/ext.rs
+  xpath/funcs/mod.rs xpath/lex.rs xpath/limits.rs
+  xpath/mod.rs xpath/nodetest.rs xpath/number.rs
+  xpath/order.rs xpath/parse.rs xpath/step_index.rs
+  xpath/str_cache.rs xpath/tests.rs xpath/value.rs
+  xpath/verify.rs
 ].freeze
 
 UNSAFE_USE = /\bunsafe\s*(?:\{|fn\b|impl\b|trait\b|extern\b)/
@@ -163,7 +164,9 @@ RAW_NODE_CROSSING =
 RAW_NODE_CROSSING_COUNTS = {
   "bridge/doc.rs" => 1,
   "bridge/fragment.rs" => 3,
-  "bridge/html.rs" => 7,
+  # 8th: an Attr's owner, read as the wrapper cache's identity key for the
+  # owner-frozen check (`check_attr_owner_frozen`); it does not escape.
+  "bridge/html.rs" => 8,
   "bridge/wrapper.rs" => 3,
 }.freeze
 
@@ -425,7 +428,7 @@ if lexbor_abi != LEXBOR_ABI_COUNTS
 end
 
 # A Lexbor function is DECLARED in one place, `lexbor/abi.rs` (bindgen's output
-# plus the three exports no header declares). A second `extern "C"` declaration of the
+# plus the exports no header declares). A second `extern "C"` declaration of the
 # same symbol gives it a second Rust type, which nothing checks agree, and on
 # macOS a declaration that matches no symbol is a NULL call rather than a link
 # error. `post_parse.rs` re-declared four generated functions that way.
@@ -442,6 +445,31 @@ unless lexbor_decls.empty?
   errors << "Lexbor functions declared outside lexbor/abi.rs: #{lexbor_decls.inspect}"
 end
 
+# Lexbor's CSS parsers are CALLED in one place each - the function that puts
+# their input through `contains_guard` first (CLAUDE.md: the guard is not
+# optional, and a new parse entry must go through it). A type alone cannot
+# say so: the raw ABI is reachable crate-wide, so a second call site would
+# compile and reach the parser unguarded. Pinned here instead.
+GUARDED_PARSES = {
+  "lxb_css_selectors_parse" => "lexbor/css_engine.rs",   # SelectorParser::parse
+  "lxb_css_stylesheet_parse" => "lexbor/stylesheet.rs",  # guarded_stylesheet
+}.freeze
+guarded_calls = Hash.new { |h, k| h[k] = Hash.new(0) }
+Dir.glob(File.join(RUST, "**", "*.rs")).sort.each do |path|
+  relative = path.delete_prefix("#{RUST}/")
+  code = comments_removed(File.binread(path))
+  GUARDED_PARSES.each_key do |name|
+    count = code.scan(/\b#{name}\s*\(/).length
+    guarded_calls[name][relative] = count unless count.zero?
+  end
+end
+GUARDED_PARSES.each do |name, home|
+  next if guarded_calls[name] == { home => 1 }
+
+  errors << "#{name} must be called exactly once, in #{home} (behind contains_guard): " \
+            "#{guarded_calls[name].inspect}"
+end
+
 # magnus's `RHash::foreach` runs its closure under magnus's own `protect`, below
 # `rb_hash_foreach`'s C frames, so a panic in it aborts the process instead of
 # raising. `glue::hash::hash_foreach` latches it; every Hash walk goes there.
@@ -462,7 +490,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 = 5
+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 " \

data/suppressions/ruby.supp

@@ -161,6 +161,20 @@
   ...
 }
 
+# The global symbol table (`global_symbols.ids`) grows in chunks as symbols are
+# interned, and lives for the life of the VM: RUBY_FREE_AT_EXIT reports its
+# chunk arrays as "definitely lost" whenever the growth happened under one of
+# our cfuncs - `parse_stylesheet` interns its hash keys with `rb_intern` on the
+# first call, and whether that call crosses a chunk boundary depends on how many
+# symbols the process made before it. Not ours to free.
+{
+  ruby-global-symbol-table
+  Memcheck:Leak
+  ...
+  fun:set_id_entry*
+  ...
+}
+
 # ---- Makiri's process-lifetime CSS compiled-selector cache ----
 # `lexbor::selector_cache` keeps compiled selector lists in a process-global
 # `HashMap<Box<[u8]>, _>` (bounded by CACHE_CAP) that lives until exit by

metadata

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