makiri 0.14.0-aarch64-linux → 0.15.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3c3ed6ee3cd5fadbf71a4841bb984d84aa09b53ae9707da72ef2a4c5e6ce2c4
-  data.tar.gz: 3e92e200b9d198936e4ae65ee7f43bd0a2271827f3324c5127ea148a4b134b44
+  metadata.gz: d9bef2471bfcd87d3e3c31bf6f4eeecef71202d81bf0bb46b7b71eee526cd1a4
+  data.tar.gz: 1836c1d1ee430cba8a058d63411259483ad84f3f4a1fdb69aae53621f1093f68
 SHA512:
-  metadata.gz: dc3c6c844fce3e704a0560b5d07908b39082b6528ecf85fb77ea6e3d15c65cea1d7ff0cd99cd48fe52f96bf74ffed160f83cb3f233bf3e6e55de2923234124c4
-  data.tar.gz: 40b616cb7581a6b2afc5a03f6bdd3f66f7cec98eec398d19bf0121fcb011ff9e2e9f7412fb39976c0638590d9a263ef8ebdd7d285891a4e093142f94c6b097f5
+  metadata.gz: 3f8c5b7d20a0190f05afd7e1d8c453979eeaf3dc7d1ec58e5314fdeb803e84d5a3bbbf6e1fa533b3827d0bc70b8b41269d5a5d2d06d79339c1244e3a5a10b7a4
+  data.tar.gz: e93f2d6a31337fc9e23782b4e3e5a37196e5ef95a92b206868721f8dc04d0263a593eb5361fef0c2fa0a67ab037a3777faafb65bcbe06fa0f45bdf215430bdd1

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,36 @@
 # 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
@@ -964,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/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/lib/makiri/version.rb

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

data/lib/makiri/xml/document.rb

@@ -34,6 +34,21 @@ module Makiri
       def dup(*)
         _copy
       end
+
+      # Always false: an XML document is in no-quirks mode, as the DOM has it.
+      # The same name as {Makiri::HTML::Document#quirks_mode?}, so a caller
+      # need not ask which kind of document it holds.
+      # @return [false]
+      def quirks_mode?
+        false
+      end
+
+      # The DOM's +document.compatMode+, which is always "CSS1Compat" for an
+      # XML document.
+      # @return [String]
+      def compat_mode
+        "CSS1Compat"
+      end
     end
   end
 end

data/script/check_alloc_failures.rb

@@ -345,8 +345,8 @@ SCENARIOS = {
   # CSS on XML: a different engine from the HTML one above - the selector is
   # lowered (css/) into an XPath AST, every node of which is a falloc site. One
   # selector per lowering shape: combinators, attribute operators, the nth and
-  # of-type arithmetic, the selector-list pseudo-classes, :lexbor-contains and
-  # namespaced type/universal selectors.
+  # of-type arithmetic, the selector-list pseudo-classes and namespaced
+  # type/universal selectors.
   "xml_css" => lambda do
     doc = Makiri::XML::Document.parse(<<~XML)
       <root xmlns:p="urn:p">
@@ -362,7 +362,7 @@ SCENARIOS = {
       ":nth-child(2n+1):not(:last-child)",
       "a:nth-last-of-type(1), :first-of-type:only-of-type",
       ":is(root > a, p|*):where(a) :empty",
-      "root:has(> b + a) a:lexbor-contains(\"BETA\" i)",
+      "root:has(> b + a) a",
       "*|a, |b, p|*",
     ].map { |s| doc.css(s, ns).map { |n| n.name }.join(",") }.join("\n")
   end,
@@ -428,6 +428,7 @@ SCENARIOS = {
   "css_stylesheet" => lambda do
     css = <<~CSS
       div.a, p#b > span { color: red; margin: 0 !important }
+      .md\\:block, :is(.a\\,b, :not(#x\\.y)) > [a="q\\\\"] { color: red }
       p::before { content: "x" }
       @media (min-width: 600px) { .x { color: blue } }
       @font-face { font-family: F; src: url(f.woff) }
@@ -770,7 +771,7 @@ guard_docs = {
   "html" => Makiri::HTML::Document.parse("<p>hello</p>"),
   "xml" => Makiri::XML::Document.parse("<r><p>hello</p></r>")
 }
-[":lexbor-contains(#x)", "p:LEXBOR-CONTAINS(*)"].each do |sel|
+[":lexbor-contains(#x)", "p:LEXBOR-CONTAINS(*)", %(p:lexbor-contains("x"))].each do |sel|
   guard_docs.each do |kind, doc|
     disarm
     3.times do

data/script/check_unsafe_boundaries.rb

@@ -66,14 +66,14 @@ UNSAFE_ISLANDS = {
   "lexbor/adapter/tree_guard.rs" => 9,
   "lexbor/chunks.rs" => 2,
   "lexbor/css_engine.rs" => 14,
-  "lexbor/css_parser.rs" => 21,
+  "lexbor/css_parser.rs" => 19,
   "lexbor/css_tokens.rs" => 10,
   "lexbor/fragment.rs" => 7,
   "lexbor/memory.rs" => 9,
   "lexbor/selector_cache.rs" => 15,
   "lexbor/selectors.rs" => 9,
   "lexbor/serialize.rs" => 2,
-  "lexbor/stylesheet.rs" => 8,
+  "lexbor/stylesheet.rs" => 9,
   "lexbor/tests.rs" => 16,
   "lexbor/xpath.rs" => 9,
   "token.rs" => 1,
@@ -100,27 +100,27 @@ FORBID_FILES = %w[
   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
+  lexbor/css_match/mod.rs lexbor/selector_text.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)/

metadata

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