sonicop 26.8.102 → 26.8.103

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea2dfe101378c37802dfe7e5cf3a4e3c3595942c75c91c9f25ade094ab11e632
-  data.tar.gz: 01e5d99dcd5989fee69f66403712918e792d0c268ea3b82096ec260dcfd3f176
+  metadata.gz: 11d1ded7e100a86c067bfd508cf4b7b3b402e2c964fb5bcbabb4f95e800551dc
+  data.tar.gz: 2e06b2ad86065842b5fda6dd9b41b798175a87b70633a205fd73fddaa611e1e2
 SHA512:
-  metadata.gz: 726107889fe04bf60cf2f056c8ca7d34c5c825650426120281e9afa88d2c819d38d7342d99cdc45dd0b81a942011e5d130f6745fd7ee6cc6c5249663526d159d
-  data.tar.gz: 51b76434f05a2b35cecc62eda0e3636592f7058ff123ab936872f577082502301a5c609828fc5d0659abd94f3d67291aa3dbc71ddd6ffc0be2fc344a13e0bf51
+  metadata.gz: e52e6bd4a26c68bd2ed6bda10bfba3772e6760c1573d81c6212391cd0bf1acdccece6b102eed1d9bbf9c2e652556772f12fa626628bb6266d9eee7d94826c314
+  data.tar.gz: 240b544b1e90d355b92025d226d4cdd4efd358e81e9bc26449d5e9f641505230c510b4389487efc936d8e6fcb8fcf281c7b18180ade2a6c0b66fe18c980912df

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,38 @@ 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,246 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 | `ce95deb` | 3,550 | 167,535 |
+| ruby/ruby | `a9c656e` | 7,465 | 756,427 |
+| Homebrew/brew | `6cf9b12` | 2,176 | 49,733 |
+| mastodon/mastodon | `3f5c32f` | 3,290 | 15,286 |
+
+ruby/ruby's reference had to be assembled from chunked runs, and 15 files under `test/ruby/` are
+excluded from it: RuboCop finds offenses in them whose text is not valid UTF-8, and its JSON
+formatter raises `source sequence is illegal/malformed utf-8` rather than emitting a document. The
+comparison for that corpus therefore covers 7,450 of its 7,465 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 **394 of RuboCop's 609 cops**: every cop RuboCop enables by default, matched name
+for name, with nothing extra on either side. The other 215 are the ones RuboCop ships switched off —
+159 `Enabled: pending` and 56 `Enabled: false` — and are not implemented yet.
 
-```bash
-cops=$(sonicop --show-cops --force-default-config \
-       | grep -B3 'Implemented: true' | grep '^[A-Z].*:$' | tr -d ':' | paste -sd, -)
+Because the two enabled 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 +51,46 @@ 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/brew | 254 | 999 | none |
+| ruby/ruby | 156 | 616 | 5 |
 
-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
+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 116 of the 616 missing and 44 of the 156 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. That is why the residue there is
+spread thinly across the Layout department instead of sitting in one cop. 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**.
+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
@@ -78,6 +111,15 @@ every offense Sonicop found in them counts as "excess". Check `summary.inspected
 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.
 
+**And sometimes it emits nothing at all.** Fifteen files under `test/ruby/` hold offenses 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 therefore looks like an empty
+file rather than a truncated one, and a chunked reference run has to tell it 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
 
 `tests/conformance/known_divergences.yml` is the machine-checked record: a divergence that is listed
@@ -88,19 +130,31 @@ 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`,
+999 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 both tools flag the same 568 files —
+neither has one the other lacks. This is why every cop other than `Lint/Syntax` matches exactly there
+despite the 1,253 offenses of difference.
+
+Within those 568 files the agreement is partial, as recovery cannot be reproduced: 498 report the
+same first diagnostic (position and message), and 223 report an identical list end to end. 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.
 
 ### 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
@@ -117,7 +171,7 @@ 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,246 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.
@@ -129,6 +183,12 @@ 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. Sonicop recognizes them —
+they appear in `--show-cops` and a configuration naming them still loads — but it does not implement
+them, so enabling one through `.rubocop.yml` or `--only` checks nothing at all. Sonicop prints a
+warning to stderr in that case rather than letting an unchecked file look clean, but a project whose
+configuration leans on those cops is outside what this document measures.
+
 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.103"
 dependencies = [
  "anyhow",
  "assert_cmd",

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sonicop"
-version = "26.8.102"
+version = "26.8.103"
 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,7 +32,7 @@ CI へ最小限の変更で導入できます。
 
 ## 主な機能
 
-Layout、Lint、Metrics、Naming、Security、Style の各部門の Cop を実装しています。
+Bundler、Gemspec、Layout、Lint、Metrics、Migration、Naming、Security、Style の各部門の Cop を実装しています。
 実装済みの Cop はリリースごとに増えるため、一覧はバイナリ自身が正本です。
 
 ```bash
@@ -107,29 +107,44 @@ 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,246 ファイルに対して、両者とも本家既定設定で検証しています。offense は Cop 名・パス・
+行・桁・終端行・終端桁・長さ・メッセージ・重大度・修正可否のすべてで突き合わせます。
+
+5 つのうち 3 つが**完全一致**です。RuboCop 自身のツリー（5,766 件）、Rails（167,535 件）、
+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 | 10.64 秒 | **2.84 秒** | 40.66 秒 | **13.60 秒** |
+| mastodon/mastodon | 3,290 | 10.78 秒 | **3.13 秒** | 33.22 秒 | **13.57 秒** |
+| Homebrew/brew | 2,176 | 11.13 秒 | **4.61 秒** | 37.89 秒 | **10.81 秒** |
+| rails/rails | 3,550 | 23.84 秒 | **10.15 秒** | 84.93 秒 | **33.69 秒** |
+| ruby/ruby | 7,465 | 95.71 秒 | **35.74 秒** | 258.87 秒 | **107.37 秒** |
 
-| 実行条件 | 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.4〜3.8 倍、単一プロセスで 2.4〜3.5 倍と幅があり、1 コーパスでは代表できません。
+単一プロセスの列のほうが安定しています。エンジンそのものを測っており、
+各ツールの並列化が対象ツリーにたまたま噛み合ったかどうかに左右されないためです。
 
-最後の行は素で叩いたときの実測ですが、**対等な比較ではありません**。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 +153,19 @@ 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 分平均のロードアベレージが 4〜29 の状態で採ったもので、**アイドル状態ではありません**。
+両者を同じ条件で測っているため倍率は保たれますが、秒数そのものは下限ではなく、静かなマシンなら
+より速く出ます。コアを奪い合うものが動いていると両者とも膨らみ、その度合いは一致しないため、
+秒数そのものが重要なときは他に負荷のない状態で測ってください。
 
 ## 開発
 

data/README.md

@@ -32,7 +32,8 @@ existing editor and CI integrations with minimal changes.
 
 ## Features
 
-Sonicop implements cops in the Layout, Lint, Metrics, Naming, Security, and Style departments.
+Sonicop implements cops in the Bundler, Gemspec, Layout, Lint, Metrics, Migration, Naming,
+Security, and Style departments.
 The implemented set grows with each release, so the binary itself is the authoritative list:
 
 ```bash
@@ -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,246 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,535) 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,24 @@ 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** |
+| rubocop/rubocop | 1,765 | 10.64 s | **2.84 s** | 40.66 s | **13.60 s** |
+| mastodon/mastodon | 3,290 | 10.78 s | **3.13 s** | 33.22 s | **13.57 s** |
+| Homebrew/brew | 2,176 | 11.13 s | **4.61 s** | 37.89 s | **10.81 s** |
+| rails/rails | 3,550 | 23.84 s | **10.15 s** | 84.93 s | **33.69 s** |
+| ruby/ruby | 7,465 | 95.71 s | **35.74 s** | 258.87 s | **107.37 s** |
 
-The gap is 2.1x to 5.8x in parallel and 2.0x to 3.7x single-process, so no single corpus summarizes
+The gap is 2.4x to 3.8x in parallel and 2.4x to 3.5x 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.
+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 +164,20 @@ 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 numbers above were taken with a one-minute load average between 4 and 29 — 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, so measure on an otherwise idle machine when the
+absolute numbers matter to you.
 
 ## 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.103'
 end

data/src/cli.rs

@@ -238,6 +238,13 @@ impl Cli {
 }
 
 pub fn run() -> i32 {
+    crate::profile::set_enabled(std::env::var_os("SONICOP_PROFILE").is_some());
+    let code = run_inner();
+    crate::profile::report(&crate::rules::rule_names().collect::<Vec<_>>());
+    code
+}
+
+fn run_inner() -> i32 {
     let arguments = match composed_arguments() {
         Ok(arguments) => arguments,
         Err(error) => {
@@ -402,8 +409,12 @@ fn try_run(cli: Cli, outputs: &[Option<PathBuf>]) -> Result<i32> {
         safe_only: cli.safe,
         ignore_disable_comments: cli.ignore_disable_comments,
         display_suppressed: cli.display_suppressed,
+        correcting: cli.correct_mode() != CorrectMode::None,
     };
     let correct_mode = cli.correct_mode();
+    if !cli.list_target_files {
+        warn_unimplemented_enabled(&config, &selection);
+    }
 
     let parallel = !cli.no_parallel && (cli.parallel || cli.stdin.is_none());
     let mut reports = if let Some(stdin_path) = &cli.stdin {
@@ -478,7 +489,7 @@ fn try_run(cli: Cli, outputs: &[Option<PathBuf>]) -> Result<i32> {
             eprintln!("{message}");
             run_errors += 1;
         }
-        if outcome.corrected_count > 0 {
+        if outcome.rewritten {
             if cli.stdin.is_some() {
                 stdin_corrected = Some(outcome.text);
             } else {
@@ -553,6 +564,19 @@ impl FailLevel {
 }
 
 fn validate_compatibility(cli: &Cli) -> Result<()> {
+    // `Lint/RedundantCopDisableDirective` reports directives that switched off cops with nothing
+    // to say, so a run narrowed to a handful of cops could only ever report every directive in the
+    // file. RuboCop refuses the combination rather than answering wrongly.
+    if cli.only.as_deref().is_some_and(|value| {
+        csv(Some(value)).iter().any(|name| {
+            matches!(
+                name.as_str(),
+                "Lint/RedundantCopDisableDirective" | "RedundantCopDisableDirective"
+            )
+        })
+    }) {
+        bail!("Lint/RedundantCopDisableDirective cannot be used with --only.");
+    }
     if cli.except.as_deref().is_some_and(|value| {
         csv(Some(value))
             .iter()
@@ -683,6 +707,49 @@ fn validate_selection(values: &[String], flag: &str, config: &Config) -> Result<
     Ok(())
 }
 
+/// Tell the user about cops that resolved to enabled but have no implementation here.
+///
+/// An unimplemented cop is never planned, so a configuration that switches one on — or an explicit
+/// `--only` naming it — yields no offenses at all where RuboCop would report some. Reporting 394 of
+/// RuboCop's 609 cops is fine as long as nobody mistakes silence for a clean file, so say which
+/// checks did not happen.
+///
+/// The note goes to stderr, never stdout: RuboCop's own `-P/--parallel is being ignored` notice
+/// goes to stdout and corrupts its JSON output, which is a mistake worth not repeating.
+fn warn_unimplemented_enabled(config: &Config, selection: &Selection) {
+    let implemented: HashSet<&str> = rule_names().collect();
+    let mut skipped = config
+        .known_cop_names()
+        .filter(|name| !implemented.contains(name))
+        .filter(|&name| {
+            let enabled = config.rule_enabled_with_pending(
+                name,
+                selection.enable_pending,
+                selection.disable_pending,
+            );
+            selection.includes(name, enabled, config.rule_safe(name))
+        })
+        .collect::<Vec<_>>();
+    if skipped.is_empty() {
+        return;
+    }
+    skipped.sort_unstable();
+    const SHOWN: usize = 5;
+    let listed = skipped[..skipped.len().min(SHOWN)].join(", ");
+    let more = skipped.len().saturating_sub(SHOWN);
+    let rest = if more > 0 {
+        format!(" and {more} more (--debug lists every unimplemented cop)")
+    } else {
+        String::new()
+    };
+    let plural = if skipped.len() == 1 { "cop" } else { "cops" };
+    eprintln!(
+        "warning: {} enabled {plural} not implemented by Sonicop; nothing was checked for {}: {listed}{rest}",
+        skipped.len(),
+        if skipped.len() == 1 { "it" } else { "them" }
+    );
+}
+
 fn debug_report(cwd: &Path, config: &Config, targets: usize, parallel: bool) {
     let implemented: HashSet<&str> = rule_names().collect();
     let mut unimplemented = config
@@ -821,7 +888,7 @@ fn filter_displayed_offenses(reports: &mut [FileReport], cli: &Cli, fail_level:
                 && (!cli.display_only_correctable || offense.is_correctable())
                 && (!cli.display_only_safe_correctable
                     || (offense.is_correctable()
-                        && offense.correction.as_ref().is_some_and(|edit| edit.safe)))
+                        && offense.corrections.iter().all(|edit| edit.safe)))
         });
     }
 }
@@ -880,6 +947,7 @@ fn render_outputs(request: &RenderRequest<'_>, reports: &[FileReport]) -> Result
                 corrected_count,
                 fail_level: fail_level.severity(),
                 safe_autocorrect: cli.correct_mode() == CorrectMode::Safe,
+                display_only_failed: cli.display_only_failed,
             },
         )?;
         if cli.display_time {

data/src/config/mod.rs

@@ -19,7 +19,7 @@ use crate::ruby_version::{
 
 use inheritance::{load_with_inheritance, merge_config};
 use loader::{find_config, find_project_root};
-use paths::{PathPatterns, compile_excludes, cop_patterns, has_hidden_component};
+use paths::{PathPatterns, compile_excludes, compile_includes, cop_patterns, has_hidden_component};
 use plugin::{belongs_to_plugin, configured_plugin_departments};
 
 pub use store::ConfigStore;
@@ -40,6 +40,7 @@ pub struct Config {
     unrecognized_cops: Vec<String>,
     includes: PathPatterns,
     excludes: HashMap<String, PathPatterns>,
+    cop_includes: HashMap<String, PathPatterns>,
 }
 
 impl Config {
@@ -106,6 +107,7 @@ impl Config {
 
         let includes = cop_patterns(&raw, "AllCops", "Include").unwrap_or_default();
         let excludes = compile_excludes(&raw);
+        let cop_includes = compile_includes(&raw);
 
         Ok(Self {
             raw,
@@ -118,6 +120,7 @@ impl Config {
             unrecognized_cops,
             includes,
             excludes,
+            cop_includes,
         })
     }
 
@@ -269,6 +272,18 @@ impl Config {
         self.excluded_by(name, path)
     }
 
+    /// Whether `name`'s own `Include` list reaches `path`.
+    ///
+    /// This is the `Include` half of RuboCop's `Cop::Base#relevant_file?`, which is what keeps the
+    /// `Bundler` and `Gemspec` cops on the files their configuration names -- `**/Gemfile`,
+    /// `**/*.gemspec` -- rather than on every Ruby file the run targets. A cop that names no
+    /// `Include` applies to all of them, and one whose list is empty to none.
+    pub fn rule_included(&self, name: &str, path: &Path) -> bool {
+        self.cop_includes
+            .get(name)
+            .is_none_or(|patterns| patterns.matches_includes(path, &self.project_root))
+    }
+
     fn excluded_by(&self, name: &str, path: &Path) -> bool {
         self.excludes
             .get(name)

data/src/config/paths.rs

@@ -19,6 +19,25 @@ pub(super) fn compile_excludes(raw: &Value) -> HashMap<String, PathPatterns> {
         .collect()
 }
 
+/// Every cop's own `Include` list.
+///
+/// `AllCops/Include` chooses the files a run inspects; a cop's own `Include` chooses which of them
+/// it applies to, which is how the `Bundler` and `Gemspec` departments stay off ordinary Ruby.
+/// A cop that names no `Include` has no entry here and applies to everything.
+pub(super) fn compile_includes(raw: &Value) -> HashMap<String, PathPatterns> {
+    let Some(mapping) = raw.as_mapping() else {
+        return HashMap::new();
+    };
+    mapping
+        .iter()
+        .filter_map(|(name, value)| {
+            let name = name.as_str()?;
+            let patterns = mapping_patterns(value.as_mapping()?, "Include")?;
+            Some((name.to_owned(), patterns))
+        })
+        .collect()
+}
+
 pub(super) fn cop_patterns(raw: &Value, name: &str, key: &str) -> Option<PathPatterns> {
     mapping_patterns(raw.as_mapping()?.get(name)?.as_mapping()?, key)
 }