sonicop 26.8.102 → 26.8.104

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea2dfe101378c37802dfe7e5cf3a4e3c3595942c75c91c9f25ade094ab11e632
-  data.tar.gz: 01e5d99dcd5989fee69f66403712918e792d0c268ea3b82096ec260dcfd3f176
+  metadata.gz: 267d186a55418ccb97a890bcea5da9eda428dd6567ae4282b61755779783d6e2
+  data.tar.gz: baa0dfdcff20c0a1888222298deab0fd2af37fd9fcd25ef8beb2871bb89083fc
 SHA512:
-  metadata.gz: 726107889fe04bf60cf2f056c8ca7d34c5c825650426120281e9afa88d2c819d38d7342d99cdc45dd0b81a942011e5d130f6745fd7ee6cc6c5249663526d159d
-  data.tar.gz: 51b76434f05a2b35cecc62eda0e3636592f7058ff123ab936872f577082502301a5c609828fc5d0659abd94f3d67291aa3dbc71ddd6ffc0be2fc344a13e0bf51
+  metadata.gz: 1f983d82729522d8a18d1155a4d9b1b6d020b837e987abc2d5bbf14558587997f1abf8808e69ae1e36132b6d15f8cac0d0cf440f116cb9280b98397d7b8f3c03
+  data.tar.gz: 2ffd0dd8db704b600fda62f08c1f61455fc36310f1adc33d4ae6f1bc1b2a53998c8034103a871e4e9e2b239f798a181a66982dafbda3d9b6ae0f5b74845d0887

data/CONFORMANCE.md

@@ -1,6 +1,6 @@
 # RuboCop conformance
 
-Snapshot date: 2026-08-12
+Snapshot date: 2026-08-14
 Reference: RuboCop 1.89.0 on Ruby 4.0.6
 Configuration: RuboCop 1.89.0 built-in defaults (`--force-default-config`) on both sides
 
@@ -9,32 +9,43 @@ Re-fetch it with `scripts/sync_default_yml.sh <rubocop-version>`.
 
 ## What is measured
 
-Five Ruby projects, 18,244 target files between them, are linted by both tools and compared offense
+Five Ruby projects, 18,251 target files between them, are linted by both tools and compared offense
 by offense. An offense is keyed by cop name, path, line and column; at each shared key the last
 line, last column, length, message, severity and correctability are compared as well.
 
 | Corpus | Commit | Target files | Reference offenses |
 |---|---|---:|---:|
-| rubocop/rubocop | `e82df38` | 1,765 | 4,142 |
-| rails/rails | `729d2e9` | 3,550 | 117,541 |
-| ruby/ruby | `52975b7` | 7,465 | 603,331 |
-| Homebrew/brew | `5d49126` | 2,175 | 38,742 |
-| mastodon/mastodon | `e5db3aa` | 3,289 | 7,610 |
+| rubocop/rubocop | `f009b33` | 1,765 | 5,766 |
+| rails/rails | `62b5458` | 3,551 | 167,760 |
+| ruby/ruby | `3349f41` | 7,466 | 761,578 |
+| Homebrew/brew | `38ee325` | 2,179 | 49,920 |
+| mastodon/mastodon | `fad3685` | 3,290 | 15,286 |
+
+The commits are pinned because the numbers move with them: check the corpora out at these before
+comparing, or a difference in the corpus will read as a difference in the port.
+
+ruby/ruby's reference had to be assembled from chunked runs, and two files are excluded from it.
+`test/ruby/test_regexp.rb` cannot be inspected at all — RuboCop's lexer raises `invalid byte
+sequence in UTF-8` on it — and `test/ruby/test_file_exhaustive.rb` holds an offense whose text is
+not valid UTF-8, which stops the JSON formatter from emitting a document. The comparison for that
+corpus therefore covers 7,464 of its 7,466 files.
 
 The **target file lists match exactly** on all five — not just the counts but the paths. That is
 worth stating separately because file discovery is where a port silently diverges first: RuboCop
 never reads `.gitignore`, applies a shebang test only to extensionless files, descends through
 directory symlinks, and treats a hidden path by its *first* component rather than by any dot in it.
 
-Only the cops Sonicop implements are compared; the reference process is restricted to them with
-`--only`. RuboCop's extension plugins are not installed, so this measures the range that can be
-checked without them.
+Sonicop implements **all 609 of RuboCop's cops**, matched name for name, with nothing extra on either
+side. That includes the 159 RuboCop ships as `Enabled: pending` and the 56 it ships as
+`Enabled: false`, neither of which a default run reaches — checking those means naming them with
+`--only` or switching them on in a configuration, exactly as with RuboCop.
 
-```bash
-cops=$(sonicop --show-cops --force-default-config \
-       | grep -B3 'Implemented: true' | grep '^[A-Z].*:$' | tr -d ':' | paste -sd, -)
+Because the two cop sets are identical, neither side is restricted with `--only`; the plain run is
+already like for like. RuboCop's extension plugins are not installed, so this measures the range
+that can be checked without them.
 
-rubocop --force-default-config --cache false --only "$cops" -f json
+```bash
+rubocop --force-default-config --cache false -f json
 sonicop --force-default-config --format json
 ```
 
@@ -45,19 +56,48 @@ sonicop --force-default-config --format json
 | rubocop/rubocop | 0 | 0 | none |
 | rails/rails | 0 | 0 | none |
 | mastodon/mastodon | 0 | 0 | none |
-| Homebrew/brew | 253 | 996 | none |
-| ruby/ruby | 89 | 346 | 1 |
-
-Homebrew's remaining difference is entirely `Lint/Syntax`; every other cop matches exactly. Most of
-ruby/ruby's is too — 117 of the 346 missing and 70 of the 89 excess are `Lint/Syntax` itself. The
-rest follows from it: a file the two disagree about is inspected by one tool and skipped by the
-other, so every offense in it lands on one side of the ledger. Both are explained under
-*Known divergences*.
-
-Autocorrect is compared the same way, byte for byte over the whole tree: run `-a` (and separately
-`-A`) with both tools from a clean checkout and diff the results. On all four corpora measured this way —
-rubocop/rubocop, rails/rails, Homebrew/brew and mastodon/mastodon — the corrected trees are
-**identical**.
+| Homebrew/brew | 263 | 997 | none |
+| ruby/ruby | 142 | 585 | 5 |
+
+Three of the five agree offense for offense — RuboCop's own tree, Rails and Mastodon — with no
+excess, no shortfall and no metadata differences anywhere.
+
+Homebrew's remaining difference is entirely `Lint/Syntax`; every other cop matches exactly. Much of
+ruby/ruby's is too, with 117 of the 585 missing and 44 of the 142 excess being `Lint/Syntax` itself,
+and the rest follows from it: a file the two disagree about is inspected by one tool and skipped by
+the other, so every offense in it lands on one side of the ledger. Counting that through, 635 of the
+727 differences sit in files one tool or the other calls a syntax error, and they are spread thinly
+across the Layout department rather than sitting in one cop. Of the 92 that do not, 77 are the
+`Style/RedundantParentheses` case under *Differences that should not be closed*, which leaves 15 —
+ten of them in TRICK entries or encoding fixtures. Both are explained under *Known divergences*.
+
+ruby/ruby also carries five differences at positions both tools reported: two `correctable` flags and
+one `last_column`/`length` pair, all on indentation cops inside files the two parse differently, plus
+one `Lint/Syntax` message naming a different token (`tLCURLY` where RuboCop says `tLAMBEG`).
+
+Autocorrect is compared the same way, byte for byte over the whole tree: run `-A` with both tools
+from a clean checkout and diff the results.
+
+| Corpus | Corrected tree |
+|---|---|
+| rubocop/rubocop | **identical** |
+| mastodon/mastodon | **identical** |
+| Homebrew/brew | 2 files differ |
+| rails/rails | 25 files differ |
+| ruby/ruby | not measurable |
+
+RuboCop's own tree and Mastodon are the hard line: a change that breaks byte equality on either is a
+regression to be fixed, not a new known divergence to be recorded.
+
+The rails/rails residue is one shape, and Homebrew contributes one more of it: the body of a
+`begin`/`rescue`/`end` ends up indented two columns off. It appears only in a full `-A` run — the
+first-pass detection matches exactly, and reducing the case to a single file reproduces nothing —
+because what differs is which correction pass a nested indentation fix lands in. Homebrew's other
+file pairs a `disable`/`enable` around `Lint/EmptyBlock`, a cop RuboCop ships as pending; the
+upstream run leaves both comments alone and Sonicop removes them.
+
+ruby/ruby cannot be measured this way at all: RuboCop's own run does not finish on it (see *Reading a
+measurement*), so there is no complete reference tree to diff against.
 
 Run the comparison on a copy of the corpus. Autocorrect rewrites the tree in place, so a run that
 shares a checkout with anything else — another comparison, a lint measurement — has both tools
@@ -70,13 +110,36 @@ Two traps make a run look better or worse than it is, and both have produced wro
 **Counts cancel out.** Comparing offense totals hides an excess and a shortfall of the same size.
 Compare the *set* of locations, then compare fields at the locations both tools produced.
 
-**RuboCop can stop early and still emit valid JSON.** On ruby/ruby its parser raises
-`invalid byte sequence in UTF-8` on `test/ruby/test_regexp.rb` and the whole run unwinds; the JSON
-formatter still writes a well-formed document from an `ensure` block. The result reports 6,924 of
-7,465 files inspected, and the 541 files after that one in sort order were never looked at — so
-every offense Sonicop found in them counts as "excess". Check `summary.inspected_file_count`
-against `summary.target_file_count` on every run. To get a complete reference for that corpus, split
-the file list into chunks and re-run each chunk past the file that killed it.
+**RuboCop can stop early.** On ruby/ruby its lexer raises `invalid byte sequence in UTF-8` on
+`test/ruby/test_regexp.rb` and the whole run unwinds. A single-invocation run reports 6,909 of 7,466
+files inspected, and the 557 files after that one in sort order were never looked at — so every
+offense Sonicop found in them counts as "excess". Check `summary.inspected_file_count` against
+`summary.target_file_count` on every run. To get a complete reference for that corpus, split the file
+list into chunks and re-run each chunk past the file that killed it.
+
+Read those two counts with `-f offenses`, not `-f json`: with the full cop set the JSON formatter
+never gets to write them (see below), and the run looks like a crash rather than a truncation.
+
+**And sometimes it emits nothing at all.** `test/ruby/test_file_exhaustive.rb` holds an offense whose
+text is not valid UTF-8, and `JSONFormatter#finished` raises `source sequence is illegal/malformed
+utf-8` while serializing — before a single byte reaches stdout. The failure is not per-file but
+per-document: one such file discards the JSON for the entire run, summary included, which is why the
+counts above have to come from another formatter.
+
+Two things about this are easy to get backwards. **What matters is the encoding of the offense text,
+not of the source.** `test/ruby/enc/test_euc_jp.rb` and `test/ruby/enc/test_shift_jis.rb` do hold
+bytes that are not valid UTF-8, yet both serialize fine on their own — their magic comments make
+RuboCop read them in their declared encoding — while `test_file_exhaustive.rb` is valid UTF-8 as a
+file. **And which files are affected depends on the cop set, not on the corpus.** Running the full
+609 excludes two files from ruby/ruby; running `--only Lint/LiteralAsCondition,Layout/IndentationWidth`
+excludes one, because neither of those two cops produces an offense whose text is ill-formed. A
+recorded exclusion count is part of a measurement's conditions, not a property of the corpus.
+
+A chunked reference run has to tell this apart from the case above: retrying one file at a time is
+right when a file killed the parser, and useless when the run never had a chance to start. Two other
+stdout notices break JSON the same way — `--parallel` being ignored under `--cache false`, and the
+plugin suggestions RuboCop prints after a run — so a reference reader should skip to the first `{`
+rather than trust byte zero.
 
 ## Known divergences
 
@@ -88,25 +151,72 @@ but no longer reproduces fails the test, and so does one that appears without be
 RuboCop parses with `parser`, an LALR parser that recovers from an error and keeps going, emitting
 further diagnostics from the recovered state. Sonicop parses with tree-sitter, which does not model
 that recovery, so the follow-on diagnostics cannot be reproduced. On Homebrew this accounts for the
-996 missing `Lint/Syntax` offenses: `class definition in method body`, `dynamic constant assignment`,
+997 missing `Lint/Syntax` offenses: `class definition in method body`, `dynamic constant assignment`,
 `cannot assign to a keyword`, and repeated `unexpected token` inside one multi-line hash.
 
-The first diagnostic in each file does match, which is what decides whether the file is inspected at
-all: RuboCop runs no cop other than `Lint/Syntax` on a file that does not parse, and Sonicop does the
-same.
+What the divergence does not change is **which** files are held to be unparseable, and that is what
+decides whether a file is inspected at all: RuboCop runs no cop other than `Lint/Syntax` on a file
+that does not parse, and Sonicop does the same. On Homebrew the two agree on the *set*, not merely on
+its size: 569 files, with the difference in either direction empty. This is why every cop other than
+`Lint/Syntax` matches exactly there despite the 1,260 offenses of difference.
+
+The agreement is not universal. On ruby/ruby the sets differ by six files: 56 agree, five are flagged
+only by Sonicop and one only by RuboCop. The five are TRICK contest entries — deliberately obfuscated
+programs, one of which is English prose that happens to parse as Ruby — where tree-sitter reports an
+error and `parser` does not. Those five hold 465 of that corpus's 773 differences.
+
+Within Homebrew's 569 files the agreement is partial, as recovery cannot be reproduced: 499 report the
+same first diagnostic (position and message), and 222 report an identical list end to end. The 277
+files in between are the divergence in its purest form — the two agree on where the file first goes
+wrong and part company on what follows. The 70
+files whose first diagnostic differs follow one shape — an endless method definition (`def to_s =
+to_str`, valid from Ruby 3.0, rejected by the default `TargetRubyVersion: 2.7`) leaves `parser`'s
+method context open, so the enclosing `class` emits `class definition in method body` when it is
+finally reduced. The diagnostic is reported at the `class` keyword, far above the line that actually
+failed, which puts it first in source order.
+
+### What is left on ruby/ruby
+
+ruby/ruby is the only corpus with a residue that is not one shape, so it is worth taking apart. Of
+its 727 differences:
+
+| | Count | |
+|---|---:|---|
+| in files one tool calls a syntax error | 635 | the recovery difference above |
+| `Style/RedundantParentheses` in one file | 77 | RuboCop's defect, see below |
+| everything else | 15 | |
+
+The last 15 are the honest remainder. Ten of them sit in TRICK entries or encoding fixtures —
+`Layout/SpaceInsideParens` five times in one obfuscated program, `Layout/TrailingWhitespace` and
+`Layout/LeadingCommentSpace` on a UTF-16 fixture that holds no BOM. Three are the `"…"%[…]` lexing
+gap described under *Grammar gaps*. That leaves two — `Lint/NestedMethodDefinition` on
+`def (obj.bar = Object.new).baz` and `Style/MixinUsage` on a top-level `include RbConfig` — which
+have not been investigated.
+
+Naming that number is the point. It was 138 before the cop fixes that landed with the 609th cop, and
+every step down came from taking one shape at a time rather than from a general improvement.
 
 ### Grammar gaps
 
 Where tree-sitter rejects code that Ruby accepts, Sonicop reports a syntax error and — following the
 rule above — reports nothing else for that file. One such gap costs every offense in the file at
 once, which makes them worth hunting: fixing eight lexer rules in the grammar fork took ruby/ruby
-from 24 affected files to 5, and the offenses Sonicop was missing there from 2,457 to 346.
+from 24 affected files to 5, and cut the offenses Sonicop was missing there by more than sevenfold.
+What is left moves with how many cops are implemented — one unparseable file costs every offense
+every cop would have reported in it — so the shortfall grows as coverage does.
 
 What remains are constructs whose ambiguity Ruby resolves with information a grammar does not have.
 `$a?0:1` is the clearest: whether `?0` is a character literal or the start of a ternary depends on
 whether the token before it completed an expression, which in turn depends on knowing that `a` is a
 local variable rather than a method call.
 
+A gap does not have to reject the file to cost offenses. `"%3d %s"%[l+1, line]` parses, but not as
+Ruby reads it: a `%` written against a string literal can only be the operator, while tree-sitter
+takes `%[…]` for a percent-literal string and yields two adjacent strings instead of a binary
+operation. Nothing downstream can recover it — the operator node the cop would report on is not in
+the tree — so `Layout/SpaceAroundOperators` misses both the `%` and the `+` nested inside the
+brackets. Three offenses on ruby/ruby come from this, all on one line of `libexec/erb`.
+
 ### Encoding — the one deliberate difference
 
 RuboCop's autocorrect ends in a plain `File.write`, so a corrected Shift_JIS file is written back as
@@ -117,11 +227,43 @@ cp932 and you get mojibake, not the source you had.
 when the correction holds a character that encoding cannot represent, leaving the file untouched
 rather than substituting something else. Drop-in compatibility reaches a long way, but not as far as
 reproducing data loss on purpose. This is the only place Sonicop knowingly differs, and it only
-shows up on files that declare a non-UTF-8 encoding — 8 of the 18,244 files measured here.
+shows up on files that declare a non-UTF-8 encoding — 8 of the 18,251 files measured here.
 
 A source declaring `ASCII-8BIT` or `binary` needs no such treatment: Ruby measures it one byte at a
 time, so Sonicop reads it that way too and the bytes go back out unchanged.
 
+## Differences that should not be closed
+
+Everything above records a place Sonicop has not reached. This section records the opposite: a
+difference where RuboCop is the one that is wrong, and matching it would mean discarding a correct
+report. The two are worth separating, because a table that mixes them reads as though every
+difference counts against the port.
+
+On ruby/ruby's `test/-ext-/bignum/test_pack.rb`, `Style/RedundantParentheses` finds 3 offenses in
+RuboCop and 79 in Sonicop. The 76 are real: they are `(-n)`, `(-n+1)` and `(+n-1)` written as method
+arguments, the same shape RuboCop reports elsewhere in the same file and in a file of its own.
+
+RuboCop drops them because of an unrelated line further down. Truncating the file shows it exactly:
+
+```
+first 82 lines + a closing end   → RuboCop reports 8
+first 83 lines + a closing end   → RuboCop reports 0    ← the 8 already reported are withdrawn
+line 83 with \xFF changed to \x00 → RuboCop reports 9
+```
+
+Line 83 is `assert_equal([-1, "\xFF"], Bug::Bignum.test_pack((-0x0FF), 1, 1, 0, BIG_ENDIAN))`, in a
+file whose first line is `# coding: ASCII-8BIT`. Reading that far makes RuboCop abandon
+`Style/RedundantParentheses` for the whole file, silently:
+
+- it is specific to that cop — `Style/StringLiterals` still reports its 10 offenses in the same file
+- it is not the cop-error path — `--raise-cop-error` says nothing
+- the file is inspected — the run reports `inspected: 1` and simply finds no offense of that cop
+- it is not a parse failure — neither tool emits `Lint/Syntax`, and `ruby -c` accepts the file
+- a synthesised minimum does not reproduce it; the surrounding file is part of the trigger
+
+Sonicop reports all 79. Bringing that down to 3 would mean suppressing correct output to match a
+defect, so the difference stands as it is.
+
 ## Limits
 
 A clean run is a property of the corpora, not a general claim. `known_divergences.yml` carries the
@@ -129,6 +271,13 @@ current list of what these corpora never exercise; the main ones are non-default
 values, extension plugins, and Windows line endings. Cops that never fire contribute nothing to a
 match count, and their silence is indistinguishable from agreement.
 
+The 215 cops RuboCop ships switched off are a limit of a different kind. They are implemented, but a
+default run never reaches them, so the corpus numbers above say nothing about them. What stands
+behind those is a separate measurement: the same corpora linted with all 609 cops switched on, on
+both sides, and the residue classified. That is weaker evidence than it sounds — a cop that never
+fires on these corpora contributes nothing either way — and the residue is not yet zero. The figures
+for that run are tracked in `known_divergences.yml` rather than here, because they are still moving.
+
 Closing that gap properly means porting RuboCop's own spec suite, which exercises each cop against
 inputs written to break it. Until that lands, this document records what was measured.
 

data/Cargo.lock

@@ -742,7 +742,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sonicop"
-version = "26.8.102"
+version = "26.8.104"
 dependencies = [
  "anyhow",
  "assert_cmd",

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sonicop"
-version = "26.8.102"
+version = "26.8.104"
 edition = "2024"
 rust-version = "1.85"
 description = "A fast, native RuboCop-compatible Ruby linter and formatter"
@@ -38,3 +38,10 @@ assert_cmd = "2.2.2"
 lto = "thin"
 codegen-units = 1
 strip = true
+
+# `cargo build --profile profiling` keeps the symbols a sampling profiler needs while
+# generating exactly the code `--release` does.
+[profile.profiling]
+inherits = "release"
+debug = 1
+strip = "none"

data/README.ja.md

@@ -32,17 +32,18 @@ CI へ最小限の変更で導入できます。
 
 ## 主な機能
 
-Layout、Lint、Metrics、Naming、Security、Style の各部門の Cop を実装しています。
-実装済みの Cop はリリースごとに増えるため、一覧はバイナリ自身が正本です。
+Bundler、Gemspec、Layout、Lint、Metrics、Migration、Naming、Security、Style の各部門の Cop を実装しています。
+一覧はバイナリ自身が正本です。
 
 ```bash
 # 認識済み Cop と実装状況の一覧
 sonicop --show-cops
 ```
 
-RuboCop 1.89 の全 609 Cop を同梱設定として認識します。実装済み Cop は検査を実行し、
-認識済みで未実装の Cop は既存設定を壊さず `--debug` で一覧表示します。本家にも存在しない
-Cop 名だけをエラーにし、必要なら `--ignore-unrecognized-cops` で続行できます。
+**RuboCop 1.89 の全 609 Cop を実装しています。** 本家のレジストリと名前まで一致しており、
+`Enabled: pending` の 159 個と `Enabled: false` の 56 個も含みます。この 215 個は本家でも
+既定の実行では走らないので、`--only` で名指しするか設定で有効にしてください。本家にも
+存在しない Cop 名だけをエラーにし、必要なら `--ignore-unrecognized-cops` で続行できます。
 
 ## インストール
 
@@ -107,29 +108,47 @@ Ruby プラグイン実行、キャッシュ再利用、カスタム Cop、実
 
 ### 適合性
 
-実装済み Cop は、正規化した JSON offense を使って RuboCop 1.89 との一致を検証済みです。
-本家の全 1,759 ファイルを本家既定設定で検査した現在のスナップショットは、参照 4,052 件中
-4,052 件すべての位置が一致（**recall 100%**）し、**誤検出とメタデータ差もともに 0 件**です。コマンド、比較範囲、測定結果は
-[CONFORMANCE.md](CONFORMANCE.md) にまとめています。Rails では Ruby 対象 3,453 ファイルと
-ルート／`guides/` の有効 Cop 一覧が完全一致し、全体の誤検出は 0 件です。
+実装済み Cop は、RuboCop 自身・Rails・Ruby・Homebrew・Mastodon の 5 プロジェクト
+計 18,251 ファイルに対して、両者とも本家既定設定で検証しています。offense は Cop 名・パス・
+行・桁・終端行・終端桁・長さ・メッセージ・重大度・修正可否のすべてで突き合わせます。
+
+5 つのうち 3 つが**完全一致**です。RuboCop 自身のツリー（5,766 件）、Rails（167,760 件）、
+Mastodon（15,286 件）で、過剰も不足もメタデータ差もありません。対象ファイル一覧は 5 つすべてで
+一致します。残る差分は `Lint/Syntax` に集中しており、本家の LALR パーサが構文エラーから回復して
+出す追加診断を tree-sitter では再現できないことによるものです。autocorrect は RuboCop 自身のツリーと
+Mastodon でバイト単位に一致します。この 2 つは死守ラインとして扱い、バイト一致が崩れた場合は
+既知差分ではなく退行として直します。
+
+コマンド、コーパスごとの数値、この種の計測が誤った結論を導く 2 つの罠は
+[CONFORMANCE.md](CONFORMANCE.md) にまとめています。
 
 ### 性能
 
-Rails 8.2.0.alpha のソースツリーで測定しました。両者とも同梱の既定設定
-（`--force-default-config`）で走らせているため Rails の `.rubocop.yml` は読まず、
-**対象ファイルは 3,550 件で完全に一致**しています。
+適合性検証に使う 5 コーパスすべてで測定しました。両者とも同梱の既定設定
+（`--force-default-config`）で走らせているためプロジェクト側の `.rubocop.yml` は読まず、
+どのコーパスでも**対象ファイル一覧は完全に一致**しています。
+
+両者とも既定の全 Cop で走らせています。**同じ 394 Cop** が名前まで一致しているため、
+どちらも絞る必要がなく、素の実行がそのまま対等な比較になります。
+各値は暖機後 2 回の最速値です。
+
+| コーパス | ファイル | RuboCop 並列 | Sonicop 並列 | RuboCop 単一 | Sonicop 単一 |
+|---|---:|---:|---:|---:|---:|
+| rubocop/rubocop | 1,765 | 11.49 秒 | **3.45 秒** | 42.49 秒 | **16.39 秒** |
+| mastodon/mastodon | 3,290 | 27.26 秒 | **6.03 秒** | 42.07 秒 | **19.53 秒** |
+| Homebrew/brew | 2,179 | 20.37 秒 | **5.36 秒** | 45.08 秒 | **16.03 秒** |
+| rails/rails | 3,551 | 45.89 秒 | **18.96 秒** | 99.56 秒 | **44.61 秒** |
+| ruby/ruby | 7,466 | 117.79 秒 | **54.97 秒** | 215.87 秒 | **100.62 秒** |
 
-| 実行条件 | RuboCop 1.89.0 | Sonicop 26.8.101 | 比 |
-|---|---:|---:|---:|
-| 同一の 28 Cop・並列 | 10.44 秒 | **2.78 秒** | 3.8 倍 |
-| 同一の 28 Cop・単一プロセス | 33.82 秒 | **10.17 秒** | 3.3 倍 |
-| 各ツールが既定で有効にする全 Cop | 22.52 秒 *(394 Cop・並列)* | **2.78 秒** *(28 Cop・並列)* | — |
+差は並列で 2.1〜4.5 倍、単一プロセスで 2.1〜2.8 倍と幅があり、1 コーパスでは代表できません。
+**単一プロセスの列を読み、並列は目安として扱ってください。** 同じ 2 つのバイナリを 1 日に
+3 回測ったところ、単一プロセスの値は毎回 16% 以内に収まったのに対し、RuboCop 自身のツリーでの
+並列の倍率は、マシンが他に何をしていたかだけで 3.3 倍から 9.2 倍まで動きました。単一プロセスは
+エンジンを測っていますが、並列はエンジンに加えて「その実行でスケジューリングがそのツリーに
+どれだけ噛み合ったか」を測っています。
 
-最後の行は素で叩いたときの実測ですが、**対等な比較ではありません**。Sonicop は RuboCop の
-609 Cop のうち 28 個しか実装しておらず、答えている問いがそもそも小さいためです。
-上 2 行は RuboCop を同じ 28 Cop に絞ったもので、エンジンの速度差はこちらが実態を表します。
-この 28 Cop での検出数は 117,541 件中 243 件（0.2%）しか違わないため、
-仕事を省いて速いわけではありません。
+仕事を省いて速いわけではありません。この同じ 394 Cop について、RuboCop 自身のツリーと
+Mastodon では**すべての offense が一致**し、autocorrect もバイト単位で一致します。
 
 再現時に注意が必要な点が 2 つあります。RuboCop は **`--cache false` と併用すると
 `--parallel` を黙って無効化します**。そのためここでの並列実行はキャッシュを有効にしたうえで
@@ -138,16 +157,20 @@ Rails 8.2.0.alpha のソースツリーで測定しました。両者とも同
 Sonicop は `--no-parallel` を渡さない限り並列です。
 
 ```bash
-# RuboCop（並列・キャッシュは毎回空・Sonicop の実装済み Cop に限定）
+# RuboCop（並列・キャッシュは毎回空・既定の全 394 Cop）
 rubocop --force-default-config --cache true --cache-root "$(mktemp -d)" \
-        --no-color --parallel --only "$COPS" -f quiet
+        --no-color --parallel -f quiet
 
 # Sonicop
 sonicop --force-default-config --format quiet
 ```
 
 測定機は Apple M2（8 コア）、Ruby 4.0.6（YJIT 利用可）、RubyGems 導入の RuboCop 1.89.0。
-各値は暖機後 2〜3 回の最速値です。
+1 分平均のロードアベレージは、計測開始時が 3.6、終了時が 9.6 でした。**アイドル状態ではありません**。
+両者を同じ条件で測っているため倍率は保たれますが、秒数そのものは下限ではなく、静かなマシンなら
+より速く出ます。コアを奪い合うものが動いていると両者とも膨らみ、その度合いは一致しません。それが
+並列の列があれだけ動く理由です。秒数そのものが重要なときは、他に負荷のない状態で測り、**実行の
+前後でロードアベレージを記録してください** — その情報が無い数値は、別の数値と比べられません。
 
 ## 開発
 

data/README.md

@@ -32,17 +32,18 @@ existing editor and CI integrations with minimal changes.
 
 ## Features
 
-Sonicop implements cops in the Layout, Lint, Metrics, Naming, Security, and Style departments.
-The implemented set grows with each release, so the binary itself is the authoritative list:
+Sonicop implements cops in the Bundler, Gemspec, Layout, Lint, Metrics, Migration, Naming,
+Security, and Style departments. The binary itself is the authoritative list:
 
 ```bash
 # Every recognized cop and its implementation status
 sonicop --show-cops
 ```
 
-The bundled upstream configuration recognizes all 609 RuboCop 1.89 cops. Implemented cops run
-normally; recognized but not-yet-implemented cops remain configuration-compatible and are
-reported by `--debug`. Truly unknown cop names still fail validation unless
+**All 609 RuboCop 1.89 cops are implemented**, matched name for name against the upstream registry.
+That includes the 159 shipped as `Enabled: pending` and the 56 shipped as `Enabled: false`, which a
+default run does not reach on either side — name them with `--only` or switch them on in a
+configuration, exactly as with RuboCop. Unknown cop names still fail validation unless
 `--ignore-unrecognized-cops` is supplied.
 
 ## Installation
@@ -117,15 +118,16 @@ reuse, custom Ruby cops, or cops outside the implemented set.
 ### Conformance
 
 The implemented cops are verified against RuboCop 1.89.0 over five Ruby projects — RuboCop itself,
-Rails, Ruby, Homebrew and Mastodon — totalling 18,244 files, with the upstream default
+Rails, Ruby, Homebrew and Mastodon — totalling 18,251 files, with the upstream default
 configuration on both sides. Every offense is compared by cop, path, line, column, last line, last
 column, length, message, severity and correctability.
 
-Three of the five match **exactly**: RuboCop's own tree (4,142 offenses), Rails (117,541) and
-Mastodon (7,610), with no excess, no shortfall and no metadata differences. The target file lists
+Three of the five match **exactly**: RuboCop's own tree (5,766 offenses), Rails (167,760) and
+Mastodon (15,286), with no excess, no shortfall and no metadata differences. The target file lists
 match exactly on all five. What remains is concentrated in `Lint/Syntax`, where RuboCop's LALR
 parser recovers from an error and emits diagnostics a tree-sitter parse cannot reconstruct.
-Autocorrect is byte-identical on every corpus it was run against.
+Autocorrect is byte-identical on RuboCop's own tree and on Mastodon, the two corpora held as a hard
+line: a change that breaks byte equality there is a regression, not a new known divergence.
 
 See [CONFORMANCE.md](CONFORMANCE.md) for the commands, the per-corpus numbers, and the two ways a
 measurement of this kind can mislead you.
@@ -136,28 +138,27 @@ Measured over all five conformance corpora. Both tools were given their own bund
 configuration (`--force-default-config`), so neither reads the project's `.rubocop.yml`, and on every
 corpus the two resolve **the same file list**.
 
-RuboCop is restricted to the 28 cops Sonicop implements, which is the only like-for-like comparison
-available. Times are the fastest of two warmed runs.
+Both tools run their full default set — **the same 394 cops**, matched name for name — so neither
+side is restricted and the comparison is like-for-like as it stands. Times are the fastest of two
+warmed runs.
 
 | Corpus | Files | RuboCop parallel | Sonicop parallel | RuboCop single | Sonicop single |
 |---|---:|---:|---:|---:|---:|
-| rubocop/rubocop | 1,765 | 5.30 s | **1.41 s** | 20.88 s | **6.22 s** |
-| mastodon/mastodon | 3,289 | 3.77 s | **1.54 s** | 11.18 s | **5.67 s** |
-| Homebrew/brew | 2,175 | 8.52 s | **1.47 s** | 19.26 s | **5.20 s** |
-| rails/rails | 3,550 | 10.62 s | **5.07 s** | 32.89 s | **15.58 s** |
-| ruby/ruby | 7,465 | 27.31 s | **11.19 s** | 96.19 s | **34.85 s** |
-
-The gap is 2.1x to 5.8x in parallel and 2.0x to 3.7x single-process, so no single corpus summarizes
-it. The single-process column is the steadier of the two — it measures the engines rather than how
-well each one's parallelism happens to fit the tree it was pointed at.
-
-Out of the box the two commands do different amounts of work — RuboCop enables 394 cops by default
-against Sonicop's 28 — so that comparison is **not** like-for-like. For the record, RuboCop's default
-parallel run takes 10.46 s on its own tree, 9.91 s on Mastodon, 10.83 s on Homebrew, 20.73 s on
-Rails and 75.05 s on Ruby.
-
-Over the 28 shared cops the two agree on **every offense** on RuboCop's own tree, on Rails and on
-Mastodon, so the speed is not bought by skipping work.
+| rubocop/rubocop | 1,765 | 11.49 s | **3.45 s** | 42.49 s | **16.39 s** |
+| mastodon/mastodon | 3,290 | 27.26 s | **6.03 s** | 42.07 s | **19.53 s** |
+| Homebrew/brew | 2,179 | 20.37 s | **5.36 s** | 45.08 s | **16.03 s** |
+| rails/rails | 3,551 | 45.89 s | **18.96 s** | 99.56 s | **44.61 s** |
+| ruby/ruby | 7,466 | 117.79 s | **54.97 s** | 215.87 s | **100.62 s** |
+
+The gap is 2.1x to 4.5x in parallel and 2.1x to 2.8x single-process, so no single corpus summarizes
+it. **Read the single-process column and treat the parallel one as indicative.** Measuring the same
+two binaries three times over a day put the single-process figures within 16% of each other every
+time, while the parallel ratio on RuboCop's own tree moved between 3.3x and 9.2x purely with what
+else the machine was doing. Single-process measures the engines; parallel measures the engines plus
+how well each one's scheduling happens to fit that tree on that run.
+
+The speed is not bought by skipping work: over those same 394 cops the two agree on **every offense**
+on RuboCop's own tree and on Mastodon, and autocorrect there is byte-identical.
 
 Two details matter for reproducing this. RuboCop **silently turns `--parallel` off when combined
 with `--cache false`**, so its parallel runs here use a cache directory that is deleted before each
@@ -166,17 +167,21 @@ overstates the difference. RuboCop's default is a single process, while Sonicop
 `--no-parallel` is passed.
 
 ```bash
-# RuboCop, parallel, cold cache, restricted to the cops Sonicop implements
+# RuboCop, parallel, cold cache, its full default set of 394 cops
 rubocop --force-default-config --cache true --cache-root "$(mktemp -d)" \
-        --no-color --parallel --only "$COPS" -f quiet
+        --no-color --parallel -f quiet
 
 # Sonicop
 sonicop --force-default-config --format quiet
 ```
 
 Machine: Apple M2 (8 cores), Ruby 4.0.6 with YJIT available, RubyGems-installed RuboCop 1.89.0.
-Measure on an otherwise idle machine: anything else competing for cores inflates both sides
-unevenly, and a contended run here reported RuboCop's Rails time as 21 s rather than 10.6 s.
+The one-minute load average was 3.6 when the run started and 9.6 when it finished — the machine was
+in use, not idle. Both tools ran under the same conditions, so the ratios hold, but the absolute
+seconds are not a floor: expect better on a quiet machine. Anything competing for cores inflates
+both sides, and not by the same factor on each, which is what makes the parallel column move as much
+as it does. If the absolute numbers matter to you, measure on an idle machine and record the load
+either side of the run — a figure without that context cannot be compared with another one.
 
 ## Development
 

data/lib/sonicop/version.rb

@@ -2,5 +2,5 @@
 
 # Generated from Cargo.toml by `rake version:sync`. Do not edit by hand.
 module Sonicop
-  VERSION = '26.8.102'
+  VERSION = '26.8.104'
 end