makiri 0.13.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48c6dfd55ed565531aea117967aee1f4b8f3405ff0e36ca8766ffa729a1ee27e
-  data.tar.gz: 1866e9eb174ea0a6428a8f1c81f65ed8756d61c2429de935876d60547a4bc6bd
+  metadata.gz: 383a2feea9ae25aca8e66985862eb3dfbbb64682771fc4578d9f0f6c11100d43
+  data.tar.gz: 774f2089e9b581b757cf0e142e937f892a87ccd71bb7c60f74666d9007bcac5c
 SHA512:
-  metadata.gz: f847d9d772a2865bcd6e3f9b1626f0b67e4215d14d844b529bd194e9d287aa288cc2a555156799f842ac68fcc13405e1cfff317a506c2476b87eb24646f17c46
-  data.tar.gz: ee1fe65b9055dc2a9c11cdbbd789544ef72ef1bd2c8fa731ab0eab2f97173125ab3f96637da903d33df76dfa80e221dd0e11abeaa446f5683e1428cc7f6552af
+  metadata.gz: 575cdf673cf1c0f2f76bc641c978a5c946e99a19ebc9bd92d761aa23ac9e7d9a72d980120c22b7bc344a95d0236bcfff6887fc09e28836f64739ca87a18c7e8d
+  data.tar.gz: 8b5f74af6c317ce0928c2b700d4061828621c4115685b80c3b49c47bf65f521f46431e4cf22ce064eadf0c30dc2f68611f84b3e4e4ead2b162ef5369c5544b7a

data/.github/workflows/ci.yml

@@ -5,6 +5,13 @@ on:
     branches: [main, master]
   pull_request:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   test:
     name: Ruby ${{ matrix.ruby }} on ${{ matrix.os }}

data/.github/workflows/conformance.yml

@@ -15,6 +15,13 @@ on:
     - cron: "37 5 * * *" # nightly, offset from the other workflows
   workflow_dispatch:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   # PR + push: HTML5 parsing conformance, plus the XPath and CSS differentials
   # over the curated corpus and a moderate batch of generated XPath expressions.

data/.github/workflows/css-match.yml

@@ -37,6 +37,13 @@ on:
     - cron: "41 4 * * *"
   workflow_dispatch:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 env:
   # Short on a push or PR, long on the nightly schedule.
   LONG: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
@@ -139,8 +146,12 @@ jobs:
       # also starts from the other's corpus (read-only: new units go to the
       # first directory). The cache prefix is libfuzzer.yml's, so the corpus
       # accumulated there carries over.
+      # Restored here, saved after the minimization below - and not on a pull
+      # request: a cache a PR saves is scoped to that PR's ref, so main and the
+      # nightly never read it, and minimizing it (~5 min) only bought a cache
+      # nobody restores.
       - name: Restore the corpus
-        uses: actions/cache@v6
+        uses: actions/cache/restore@v6
         with:
           path: ext/makiri/rust/fuzz/corpus/${{ matrix.target }}
           key: cargo-fuzz-corpus-${{ matrix.target }}-${{ github.run_id }}
@@ -171,6 +182,32 @@ jobs:
             -dict=css.dict \
             -print_final_stats=1
 
+      # The corpus is saved after every main/nightly run, so without this it
+      # only grows: every nightly hour adds units and nothing ever drops one.
+      # It reached ~58k files (with the sibling, ~107k units replayed before
+      # the first mutation) of which libFuzzer kept ~2.8k, and a short run
+      # spent its whole 180 s replaying - 0 new units, no fuzzing at all.
+      # Minimizing before the save keeps only what adds coverage. The first
+      # run after a long gap pays one replay of the backlog; later ones a
+      # few thousand units.
+      - name: Minimize the corpus before it is cached
+        if: github.event_name != 'pull_request'
+        working-directory: ext/makiri/rust/fuzz
+        run: |
+          before=$(ls corpus/${{ matrix.target }} | wc -l)
+          cargo fuzz cmin ${{ matrix.target }} corpus/${{ matrix.target }} -- \
+            -max_len=4096 \
+            -timeout=30
+          after=$(ls corpus/${{ matrix.target }} | wc -l)
+          echo "corpus/${{ matrix.target }}: $before -> $after files"
+
+      - name: Save the corpus
+        if: github.event_name != 'pull_request'
+        uses: actions/cache/save@v6
+        with:
+          path: ext/makiri/rust/fuzz/corpus/${{ matrix.target }}
+          key: cargo-fuzz-corpus-${{ matrix.target }}-${{ github.run_id }}
+
       - name: Upload reproducers
         if: failure()
         uses: actions/upload-artifact@v4

data/.github/workflows/security.yml

@@ -8,6 +8,13 @@ on:
     - cron: "17 19 * * *"
   workflow_dispatch:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   # A "C safety lint" job stood here (`rake security:clint`, over
   # script/check_c_safety.rb). It enforced rules about C that no longer exists -

data/.github/workflows/valgrind.yml

@@ -23,6 +23,13 @@ on:
     - cron: "0 2 * * *"
   workflow_dispatch:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   # Valgrind memcheck on the full spec suite.  Complements ASan by catching
   # layout-independent errors ASan misses: use of uninitialised values, and
@@ -111,8 +118,8 @@ jobs:
   # (parse/drop cycles) scale their iteration count down under stress
   # (`gc_churn_iters` / `GC_COMPACT_ITERS`) because each stressed iteration is
   # orders of magnitude heavier; `GC_COMPACT_ITERS` below tunes the total runtime
-  # (~6-9 min on CI at 200).  An earlier version forced GC.stress onto the
-  # *entire* suite (~800 examples): it ran 1h40m+ and never finished, while
+  # (~14.5 min on CI at 200 in one job, hence the three shards below).  An
+  # earlier version forced GC.stress onto the *entire* suite (~800 examples): it ran 1h40m+ and never finished, while
   # testing borrowed-pointer discipline on hundreds of examples that have none.
   # The rest of the suite still runs in ci.yml.
   #
@@ -123,7 +130,7 @@ jobs:
     # Pull requests, nightly and on demand - not on push (the valgrind job is the
     # post-merge gate). See the note under `on:` for why pull requests.
     if: github.event_name != 'push'
-    name: GC.auto_compact + GC.stress (Ruby ${{ matrix.ruby }})
+    name: GC.auto_compact + GC.stress (Ruby ${{ matrix.ruby }}, ${{ matrix.shard.name }})
     runs-on: ubuntu-latest
     timeout-minutes: 30
     env:
@@ -137,6 +144,17 @@ jobs:
       fail-fast: false
       matrix:
         ruby: ["3.4"]
+        # Split by spec file into three ~equal parts (measured per file: the
+        # handler spec alone is a third, attribute + source_location another).
+        # The last shard is everything ELSE, so a newly tagged file lands
+        # there rather than in no shard; rebalance if it grows past the others.
+        shard:
+          - name: xpath_handler
+            args: spec/xpath_handler_spec.rb
+          - name: attribute
+            args: spec/attribute_spec.rb spec/source_location_spec.rb
+          - name: rest
+            args: --exclude-pattern "spec/{xpath_handler,attribute,source_location}_spec.rb" spec
 
     steps:
       - name: Checkout (with vendored Lexbor submodule)
@@ -166,4 +184,4 @@ jobs:
       # auto_compact globally and wrap each example in GC.stress; --tag gc_compact
       # limits the run to the borrowed-pointer examples.
       - name: Run GC-sensitive examples under GC.auto_compact + GC.stress
-        run: bundle exec rspec --tag gc_compact spec
+        run: bundle exec rspec --tag gc_compact ${{ matrix.shard.args }}

data/.github/workflows/verify.yml

@@ -1,11 +1,37 @@
 name: Verify
 
 on:
+  # Ten minutes of proofs, over the Ruby-free engine only - so they run when
+  # that engine (or how it is built) changes, not on every push.
   push:
     branches: [main, master]
+    paths: &kani-paths
+      # The proofs build `--no-default-features`, so the Ruby/Lexbor layers
+      # below are compiled out of them; a change confined to those cannot
+      # change a proof's outcome. Everything else under src/ stays in, since
+      # the harnesses reach the engine's shared modules (limits, text, ...).
+      - "ext/makiri/rust/src/**"
+      - "!ext/makiri/rust/src/bridge/**"
+      - "!ext/makiri/rust/src/glue/**"
+      - "!ext/makiri/rust/src/lexbor/**"
+      - "!ext/makiri/rust/src/css/**"
+      - "!ext/makiri/rust/src/init.rs"
+      - "ext/makiri/rust/build.rs"
+      - "ext/makiri/rust/Cargo.toml"
+      - "ext/makiri/rust/Cargo.lock"
+      - "Rakefile"
+      - ".github/workflows/verify.yml"
   pull_request:
+    paths: *kani-paths
   workflow_dispatch:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   # A CBMC job stood here and proved ext/makiri/{core,xml,xpath}/*.c. Those
   # files are gone, and `rake verify` with them: every one of its fifteen

data/CHANGELOG.md

@@ -1,5 +1,110 @@
 # Changelog
 
+## [0.15.0] - 2026-10-09
+
+### Added
+
+* `Makiri::HTML::Document#create_loose_dom_element(qualified_name, prefix,
+  local_name, namespace_uri)`, like the XML Document's: the local name is
+  taken as given (`"Foo:Bar"` keeps its colon and case). Names the DOM
+  refuses raise `ArgumentError`.
+* `Makiri::XML::Document#quirks_mode?` (always `false`) and `#compat_mode`
+  (always `"CSS1Compat"`), as on the HTML Document.
+
+### Changed
+
+* `:lexbor-contains()` is no longer supported. `#css` / `#at_css` /
+  `#matches?` raise `Makiri::CSS::SyntaxError` for it (HTML and XML), and
+  `parse_stylesheet` reports its rule as `:bad_style`. Use XPath `contains()`
+  instead.
+* HTML `#css` / `#at_css` / `#matches?` raise `Makiri::Error` ("could not be
+  run") for `:current(S)` instead of matching nothing.
+
+### Fixed
+
+* `parse_stylesheet` keeps escapes in a selector's `:text`: `.md\:block` came
+  back as `.md:block`. `:current(S)` keeps its argument, and a rule
+  with `[|a]` is no longer reported as `:bad_style`.
+* `parse_stylesheet` trims only CSS whitespace and never an escaped one:
+  `screen\ ` came back as `screen\`. A `:bad_style`'s `selector_text` no
+  longer keeps the whitespace before its `{`.
+* HTML `:has()` with a descendant combinator is no longer slow on deep
+  documents: `:has(* * x)` exceeded the work budget at 200 levels.
+
+## [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
@@ -890,14 +995,3 @@ Tooling
   benchmark harness (`rake bench`); conformance harnesses (html5lib-tests, WPT
   domxpath, CSS differential vs `Nokogiri::HTML5`). GitHub Actions CI across
   Ruby 3.2–4.0 × Ubuntu/macOS plus a sanitizer job.
-
-[0.9.0]: https://github.com/takahashim/makiri/compare/v0.8.0...v0.9.0
-[0.8.0]: https://github.com/takahashim/makiri/compare/v0.7.0...v0.8.0
-[0.7.0]: https://github.com/takahashim/makiri/compare/v0.6.0...v0.7.0
-[0.6.0]: https://github.com/takahashim/makiri/compare/v0.5.1...v0.6.0
-[0.5.1]: https://github.com/takahashim/makiri/compare/v0.5.0...v0.5.1
-[0.5.0]: https://github.com/takahashim/makiri/compare/v0.4.0...v0.5.0
-[0.4.0]: https://github.com/takahashim/makiri/compare/v0.3.0...v0.4.0
-[0.3.0]: https://github.com/takahashim/makiri/compare/v0.2.0...v0.3.0
-[0.2.0]: https://github.com/takahashim/makiri/compare/v0.1.0...v0.2.0
-[0.1.0]: https://github.com/takahashim/makiri/releases/tag/v0.1.0

data/NOKOGIRI_DIFFERENCES.md

@@ -245,18 +245,12 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
     text-containment extension. Use XPath (`xpath("//p[contains(., 'x')]")`) or
     Enumerable (`css('li')[1]`) for the rest.
     Standard Level-4 selectors (`:is` / `:where` / `:has`) are supported; some of which Nokogiri rejects.
-  * `:lexbor-contains("text")` - Lexbor's spelling of the jQuery `:contains()`
-    substring filter, matching an element whose text contains the string;
-    append ` i` (`:lexbor-contains("text" i)`) for an ASCII case-insensitive
-    match. (Nokogiri's name `:contains` is not an alias.) **XML only**: it
-    lowers to XPath `child::text()[contains(., "text")]`, testing the
-    element's immediate child text nodes, not the deep string-value. HTML no
-    longer supports it - `lexbor::css_match`, the safe-Rust port that
-    replaced Lexbor's own matcher for HTML, deliberately does not reimplement
-    it, so a well-formed `:lexbor-contains()` now raises `Makiri::Error`
-    ("could not be run") on HTML rather than ever matching (it still PARSES,
-    and an actually malformed one still raises `Makiri::CSS::SyntaxError`, as
-    before).
+  * There is no text-containment pseudo-class. Nokogiri's `:contains()` is
+    not supported, and neither is Lexbor's `:lexbor-contains()`: it raises
+    `Makiri::CSS::SyntaxError` on HTML and XML alike, like any unknown
+    pseudo-class (Lexbor's parser for it had memory-safety bugs, so Makiri
+    never lets it run). Use XPath instead:
+    `xpath('//p[contains(., "text")]')`.
 * Untyped `:*-of-type` (`:first-of-type`, `:nth-of-type(an+b)`, ... with no type
   selector) is supported and correct on both HTML and XML - the "type" is the
   element's own expanded name.

data/README.md

@@ -184,6 +184,12 @@ 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

data/Rakefile

@@ -94,10 +94,12 @@ end
 # the report down to errors whose stack touches our extension, so we no longer
 # have to fetch ruby.supp from ruby/ruby (that path was removed upstream).
 #
-# We keep this job's historical contract: catch *use of uninitialised values*
-# and *invalid reads/writes* (incl. intra-arena overflows) - NOT leaks (leak
-# detection stays with `rake leaks`). So we override ruby_memcheck's defaults,
-# which disable undef-value errors and turn on full leak-check.
+# The job catches *use of uninitialised values* and *invalid reads/writes*
+# (incl. intra-arena overflows), and also any "definitely lost" block whose
+# stack touches our extension - the one leak gate with no frequency threshold
+# (`rake leaks`, macOS, flags only stacks repeated >= 30x). It once meant to
+# leave leaks out and could not: see `--leak-check` below. ruby_memcheck's
+# defaults disable undef-value errors, so we override them.
 #
 # `filter_all_errors: true` is essential: by default ruby_memcheck only applies
 # its "stack must touch the makiri binary" filter to *leak*-kind errors
@@ -146,7 +148,19 @@ begin
       # post-merge push gate turns it off (VALGRIND_TRACK_ORIGINS=no) to run in
       # ~half the time, while the nightly / manual runs keep it on for the backtrace.
       "--track-origins=#{ENV.fetch('VALGRIND_TRACK_ORIGINS', 'yes')}",
-      "--leak-check=no",        # leaks are `rake leaks`' job, not this one
+      # Leaks ARE checked here, whatever this says: ruby_memcheck always runs
+      # valgrind with --xml=yes, and in XML mode memcheck writes its leak
+      # records even under --leak-check=no (a "definitely lost" in a spec's
+      # child process failed run 37864917248 that way). So say what happens,
+      # and keep ruby_memcheck's own leak kinds - these options REPLACE its
+      # defaults rather than adding to them, and without the line below
+      # valgrind's default (definite,possible) fails the job on a "possibly
+      # lost" too. A spec that runs Ruby in a child must leave
+      # RUBY_FREE_AT_EXIT set there (it is inherited): without it the child's
+      # live strings at exit are reported as definitely lost through our
+      # frames (PR #55).
+      "--leak-check=full",
+      "--show-leak-kinds=definite",
     ],
   )
 

data/ext/makiri/rust/build.rs

@@ -193,7 +193,6 @@ fn main() {
         .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")
         // The token-type FLAGS are in `enum lxb_html_token_type` - no trailing
@@ -283,6 +282,7 @@ fn main() {
         .allowlist_function("lxb_dom_document_type_create")
         .allowlist_function("lxb_dom_document_import_node")
         .allowlist_function("lexbor_str_init")
+        .allowlist_function("lxb_html_document_create")
         .allowlist_function("lxb_html_document_destroy")
         // The document title reader, generated rather than hand-declared like
         // the rest of this list.
@@ -292,7 +292,6 @@ fn main() {
         .allowlist_function("lxb_css_stylesheet_destroy")
         .allowlist_function("lxb_css_property_serialize")
         .allowlist_function("lxb_css_property_serialize_name")
-        .allowlist_function("lxb_css_selector_serialize_chain")
         // One node's own markup, plain and pretty: Makiri drives the walk
         // itself (`adapter::html::serialize`), so a <template> writes its
         // contents and not its own children, as the HTML Standard says, and
@@ -416,12 +415,6 @@ const UNDECLARED_EXPORTS: &[(&str, &str, &str, &str)] = &[
         "lxb_dom_element_t *element, const lxb_char_t *prefix, size_t prefix_len, \
          const lxb_char_t *lname, size_t lname_len",
     ),
-    (
-        "lexbor/ns/ns.c",
-        "LXB_API const lxb_ns_data_t *",
-        "lxb_ns_append",
-        "lexbor_hash_t *hash, const lxb_char_t *link, size_t length",
-    ),
 ];
 
 fn check_undeclared_exports(include: &std::path::Path) {

data/ext/makiri/rust/fuzz/fuzz_targets/html_css_diff.rs

@@ -22,7 +22,9 @@
 //! (`:checked` / `:disabled` / `:enabled`, and `:read-only` / `:read-write`,
 //! which ask the same `is_disabled`), `of S`, `An+B` past 2^53, a
 //! compound that starts with a list pseudo-class where it has several
-//! candidates (Lexbor tries only the first - found by this target), and,
+//! candidates (Lexbor tries only the first - found by this target), a
+//! compound holding one after `+` in a `:has()` argument (Lexbor stops after
+//! the first pair it fails), and,
 //! on a document with foreign elements, the HTML Standard's case-sensitivity
 //! and qualified-name rules for type and attribute selectors. A selector either engine refuses is not compared either.
 //!
@@ -173,6 +175,8 @@ impl Shape {
                 // Whether the compound being walked starts with a list
                 // pseudo-class (`:is()`, `:where()`, `:not()`, `:has()`).
                 let mut leads_with_list = false;
+                // How the compound being walked attaches to the one before.
+                let mut attached = Combinator::Descendant;
                 let mut first = true;
                 let mut sel: Option<Selector<'_>> = list.first();
                 while let Some(s) = sel {
@@ -182,6 +186,7 @@ impl Shape {
                     }
                     let combinator = s.combinator();
                     if first || combinator != Combinator::Close {
+                        attached = combinator;
                         // The compound before this one is searched over every
                         // ancestor / preceding sibling when this one attaches
                         // by a descendant or `~` combinator.
@@ -199,6 +204,18 @@ impl Shape {
                             shape.departs = true;
                         }
                     }
+                    // In a `:has()` argument, a compound attached by `+` that
+                    // holds `:is()` / `:not()` / `:where()` / `:has()`: Lexbor
+                    // stops after the first pair that fails it.
+                    if in_has
+                        && attached == Combinator::NextSibling
+                        && matches!(
+                            s.simple(),
+                            Simple::PseudoClassFunction(FunctionArg::Selectors { .. })
+                        )
+                    {
+                        shape.departs = true;
+                    }
                     first = false;
                     shape.simple(s, in_has, &mut work);
                     sel = s.next();
@@ -211,7 +228,7 @@ impl Shape {
     fn simple<'p>(&mut self, s: Selector<'p>, in_has: bool, work: &mut Vec<(Lists<'p>, bool)>) {
         match s.combinator() {
             Combinator::Descendant | Combinator::SubsequentSibling => self.backtracks += 1,
-            Combinator::Other => self.departs = true,
+            Combinator::Column | Combinator::Other => self.departs = true,
             _ => {}
         }
         let upper = s.name().iter().any(u8::is_ascii_uppercase);
@@ -245,7 +262,8 @@ impl Shape {
                     }
                     work.push((lists, in_has || has));
                 }
-                FunctionArg::Contains(_) => self.departs = true,
+                // Both raised by the port and matched by Lexbor.
+                FunctionArg::Contains | FunctionArg::Current(_) => self.departs = true,
                 FunctionArg::Other => {}
             },
             _ => {}

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

@@ -34,8 +34,8 @@ use crate::bridge::xml::xml_node_document;
 use crate::bridge::xml::{xml_mut_result, xml_node_unwrap};
 use crate::lexbor::adapter::cross_import::cross_xml_to_html;
 use crate::lexbor::adapter::html::{RawDoc, RawNode};
-use crate::lexbor::adapter::post_parse::{parse_html, HtmlParseError};
-use crate::lexbor::adapter::tree_guard::{DepthLimit, MAX_SELECT_OPTIONS};
+use crate::lexbor::adapter::post_parse::{empty_html_document, parse_html, HtmlParseError};
+use crate::lexbor::adapter::tree_guard::{DepthLimit, GuardStop, MAX_SELECT_OPTIONS};
 
 /* ------------------------------------------------------------------ *
  * parsing                                                            *
@@ -49,13 +49,24 @@ pub fn select_options_error() -> Error {
     ))
 }
 
+/// The error for a parse the guard refused (`GuardStop`), for a document and
+/// a fragment alike: the one place that maps a stop to its exception.
+pub fn guard_error(stop: GuardStop, limit: DepthLimit) -> Error {
+    match stop {
+        GuardStop::TooDeep => tree_depth_error(limit),
+        GuardStop::TooManyOptions => select_options_error(),
+    }
+}
+
 /// The error for a parse the tree-depth limit refused: `Makiri::Error`, naming
 /// the limit, for a document and a fragment alike.
 pub fn tree_depth_error(limit: DepthLimit) -> Error {
     match limit.max_depth() {
         Some(n) => makiri_error(format!("document tree depth limit exceeded ({n})")),
-        /* Unreachable: an unlimited parse is never refused for depth. */
-        None => makiri_error("document tree depth limit exceeded"),
+        /* An unlimited parse is never refused for depth. */
+        None => crate::bridge::ruby::internal_error(
+            "a parse with no tree-depth limit was refused for depth",
+        ),
     }
 }
 
@@ -91,8 +102,7 @@ pub fn parse_document(source: Value, limit: DepthLimit) -> Result<Value, Error>
     drop(owned);
 
     let parsed = result.map_err(|e| match e {
-        HtmlParseError::TooDeep => tree_depth_error(limit),
-        HtmlParseError::TooManyOptions => select_options_error(),
+        HtmlParseError::Guard(stop) => guard_error(stop, limit),
         HtmlParseError::Failed => makiri_error("failed to parse HTML document"),
     })?;
     /* The GC learns the arena's size in `install`; `owned` is already gone, so
@@ -100,12 +110,24 @@ pub fn parse_document(source: Value, limit: DepthLimit) -> Result<Value, Error>
     Ok(shell.install_html(parsed))
 }
 
+/// An empty HTML document - no children - in `compat_mode` (Lexbor's
+/// numbering): `Makiri::HTML::Document.new` (no-quirks) and the copy
+/// `Document#dup` fills.
+pub fn new_empty_document(compat_mode: u32) -> Result<Value, Error> {
+    /* The wrapper first, while nothing needs freeing - see DocumentShell. */
+    let shell = DocumentShell::new(DocKind::Html);
+    let parsed = empty_html_document(compat_mode)
+        .map_err(|_| makiri_error("failed to create HTML document"))?;
+    Ok(shell.install_html(parsed))
+}
+
 /* ------------------------------------------------------------------ *
  * read-only accessors                                                *
  * ------------------------------------------------------------------ */
 
-/// `Document#root`: the root Element node, or nil (unreachable today - the HTML
-/// parser inserts html/head/body even for empty input).
+/// `Document#root`: the root Element node, or nil - for `Document.new`, or once
+/// the root is removed (the HTML parser inserts html/head/body even for empty
+/// input).
 pub fn document_root(rb_doc: Value) -> Result<Option<Value>, Error> {
     let Some(root) = html_doc(&rb_doc).as_node().document_root() else {
         return Ok(None);

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

@@ -0,0 +1,47 @@
+//! The errors the DOM's insertion rules raise, worded once for HTML and XML.
+//!
+//! Both representations keep a refusal's reason as a
+//! [`PreInsertError`](crate::dom_rules::PreInsertError) all the way here, so
+//! the same broken rule reads the same in either - XML used to fold every rule
+//! but two into one sentence.
+
+#![forbid(unsafe_code)]
+
+use crate::bridge::ruby::makiri_error;
+use crate::dom_rules::{Hierarchy as H, PreInsertError, Violation};
+use magnus::Error;
+
+/// The `Makiri::Error` an insertion `e` refused raises.
+pub fn pre_insert_error(e: PreInsertError) -> Error {
+    makiri_error(message(e))
+}
+
+fn message(e: PreInsertError) -> &'static str {
+    match e {
+        PreInsertError::NoParent { replacing: true } => "cannot replace a node with no parent",
+        PreInsertError::NoParent { replacing: false } => {
+            "cannot add a sibling to a node with no parent"
+        }
+        /* Unreachable through either representation's insertion, which takes
+         * the reference child from the parent it names; worded all the same. */
+        PreInsertError::Rule(Violation::NotFound) => {
+            "the reference node is not a child of the parent"
+        }
+        PreInsertError::Rule(Violation::HierarchyRequest(h)) => match h {
+            H::ParentNotContainer => {
+                "only a document, a document fragment or an element can have children"
+            }
+            H::Ancestor => "cannot insert a node into its own subtree",
+            H::AttributeNode => "an attribute node cannot be inserted into the tree",
+            H::DocumentNode => "a document node cannot be inserted into the tree",
+            H::UnsupportedNode => "this kind of node cannot be inserted into the tree",
+            H::DoctypeParent => "a doctype node can only be a child of the document",
+            H::DuplicateDoctype => "the document already has a doctype",
+            H::DoctypeAfterElement | H::ElementBeforeDoctype => {
+                "a doctype must precede the document element"
+            }
+            H::SecondDocumentElement => "the document already has a root element",
+            H::TextUnderDocument => "text cannot be a child of the document",
+        },
+    }
+}