sonicop 26.8.103 → 26.8.104

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11d1ded7e100a86c067bfd508cf4b7b3b402e2c964fb5bcbabb4f95e800551dc
-  data.tar.gz: 2e06b2ad86065842b5fda6dd9b41b798175a87b70633a205fd73fddaa611e1e2
+  metadata.gz: 267d186a55418ccb97a890bcea5da9eda428dd6567ae4282b61755779783d6e2
+  data.tar.gz: baa0dfdcff20c0a1888222298deab0fd2af37fd9fcd25ef8beb2871bb89083fc
 SHA512:
-  metadata.gz: e52e6bd4a26c68bd2ed6bda10bfba3772e6760c1573d81c6212391cd0bf1acdccece6b102eed1d9bbf9c2e652556772f12fa626628bb6266d9eee7d94826c314
-  data.tar.gz: 240b544b1e90d355b92025d226d4cdd4efd358e81e9bc26449d5e9f641505230c510b4389487efc936d8e6fcb8fcf281c7b18180ade2a6c0b66fe18c980912df
+  metadata.gz: 1f983d82729522d8a18d1155a4d9b1b6d020b837e987abc2d5bbf14558587997f1abf8808e69ae1e36132b6d15f8cac0d0cf440f116cb9280b98397d7b8f3c03
+  data.tar.gz: 2ffd0dd8db704b600fda62f08c1f61455fc36310f1adc33d4ae6f1bc1b2a53998c8034103a871e4e9e2b239f798a181a66982dafbda3d9b6ae0f5b74845d0887

data/CONFORMANCE.md

@@ -9,34 +9,39 @@ Re-fetch it with `scripts/sync_default_yml.sh <rubocop-version>`.
 
 ## What is measured
 
-Five Ruby projects, 18,246 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 | `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 |
+| 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 |
 
-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 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.
 
-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.
+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.
 
-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
+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.
 
 ```bash
@@ -51,18 +56,20 @@ sonicop --force-default-config --format json
 | rubocop/rubocop | 0 | 0 | none |
 | rails/rails | 0 | 0 | none |
 | mastodon/mastodon | 0 | 0 | none |
-| Homebrew/brew | 254 | 999 | none |
-| ruby/ruby | 156 | 616 | 5 |
+| 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 116 of the 616 missing and 44 of the 156 excess being `Lint/Syntax` itself,
+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. 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*.
+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
@@ -103,22 +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.
-
-**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.
+**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
 
@@ -130,23 +151,51 @@ 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
-999 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.
 
 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
+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
@@ -161,6 +210,13 @@ What remains are constructs whose ambiguity Ruby resolves with information a gra
 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
@@ -171,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,246 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
@@ -183,11 +271,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.
+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.103"
+version = "26.8.104"
 dependencies = [
  "anyhow",
  "assert_cmd",

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sonicop"
-version = "26.8.103"
+version = "26.8.104"
 edition = "2024"
 rust-version = "1.85"
 description = "A fast, native RuboCop-compatible Ruby linter and formatter"

data/README.ja.md

@@ -33,16 +33,17 @@ CI へ最小限の変更で導入できます。
 ## 主な機能
 
 Bundler、Gemspec、Layout、Lint、Metrics、Migration、Naming、Security、Style の各部門の Cop を実装しています。
-実装済みの 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` で続行できます。
 
 ## インストール
 
@@ -108,10 +109,10 @@ Ruby プラグイン実行、キャッシュ再利用、カスタム Cop、実
 ### 適合性
 
 実装済み Cop は、RuboCop 自身・Rails・Ruby・Homebrew・Mastodon の 5 プロジェクト
-計 18,246 ファイルに対して、両者とも本家既定設定で検証しています。offense は Cop 名・パス・
+計 18,251 ファイルに対して、両者とも本家既定設定で検証しています。offense は Cop 名・パス・
 行・桁・終端行・終端桁・長さ・メッセージ・重大度・修正可否のすべてで突き合わせます。
 
-5 つのうち 3 つが**完全一致**です。RuboCop 自身のツリー（5,766 件）、Rails（167,535 件）、
+5 つのうち 3 つが**完全一致**です。RuboCop 自身のツリー（5,766 件）、Rails（167,760 件）、
 Mastodon（15,286 件）で、過剰も不足もメタデータ差もありません。対象ファイル一覧は 5 つすべてで
 一致します。残る差分は `Lint/Syntax` に集中しており、本家の LALR パーサが構文エラーから回復して
 出す追加診断を tree-sitter では再現できないことによるものです。autocorrect は RuboCop 自身のツリーと
@@ -133,15 +134,18 @@ Mastodon でバイト単位に一致します。この 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 秒** |
-
-差は並列で 2.4〜3.8 倍、単一プロセスで 2.4〜3.5 倍と幅があり、1 コーパスでは代表できません。
-単一プロセスの列のほうが安定しています。エンジンそのものを測っており、
-各ツールの並列化が対象ツリーにたまたま噛み合ったかどうかに左右されないためです。
+| 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 秒** |
+
+差は並列で 2.1〜4.5 倍、単一プロセスで 2.1〜2.8 倍と幅があり、1 コーパスでは代表できません。
+**単一プロセスの列を読み、並列は目安として扱ってください。** 同じ 2 つのバイナリを 1 日に
+3 回測ったところ、単一プロセスの値は毎回 16% 以内に収まったのに対し、RuboCop 自身のツリーでの
+並列の倍率は、マシンが他に何をしていたかだけで 3.3 倍から 9.2 倍まで動きました。単一プロセスは
+エンジンを測っていますが、並列はエンジンに加えて「その実行でスケジューリングがそのツリーに
+どれだけ噛み合ったか」を測っています。
 
 仕事を省いて速いわけではありません。この同じ 394 Cop について、RuboCop 自身のツリーと
 Mastodon では**すべての offense が一致**し、autocorrect もバイト単位で一致します。
@@ -162,10 +166,11 @@ sonicop --force-default-config --format quiet
 ```
 
 測定機は Apple M2（8 コア）、Ruby 4.0.6（YJIT 利用可）、RubyGems 導入の RuboCop 1.89.0。
-上の値は 1 分平均のロードアベレージが 4〜29 の状態で採ったもので、**アイドル状態ではありません**。
+1 分平均のロードアベレージは、計測開始時が 3.6、終了時が 9.6 でした。**アイドル状態ではありません**。
 両者を同じ条件で測っているため倍率は保たれますが、秒数そのものは下限ではなく、静かなマシンなら
-より速く出ます。コアを奪い合うものが動いていると両者とも膨らみ、その度合いは一致しないため、
-秒数そのものが重要なときは他に負荷のない状態で測ってください。
+より速く出ます。コアを奪い合うものが動いていると両者とも膨らみ、その度合いは一致しません。それが
+並列の列があれだけ動く理由です。秒数そのものが重要なときは、他に負荷のない状態で測り、**実行の
+前後でロードアベレージを記録してください** — その情報が無い数値は、別の数値と比べられません。
 
 ## 開発
 

data/README.md

@@ -33,17 +33,17 @@ existing editor and CI integrations with minimal changes.
 ## Features
 
 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:
+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
@@ -118,11 +118,11 @@ 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,246 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 (5,766 offenses), Rails (167,535) and
+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.
@@ -144,15 +144,18 @@ warmed runs.
 
 | Corpus | Files | RuboCop parallel | Sonicop parallel | RuboCop single | Sonicop single |
 |---|---:|---:|---:|---:|---:|
-| 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.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.
+| 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.
@@ -173,11 +176,12 @@ sonicop --force-default-config --format quiet
 ```
 
 Machine: Apple M2 (8 cores), Ruby 4.0.6 with YJIT available, RubyGems-installed RuboCop 1.89.0.
-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
+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, so measure on an otherwise idle machine when the
-absolute numbers matter to you.
+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.103'
+  VERSION = '26.8.104'
 end

data/src/config/loader.rs

@@ -48,6 +48,48 @@ fn home_directory() -> Option<PathBuf> {
     resolve_home_directory(|key| std::env::var_os(key))
 }
 
+/// `base_dir_for_path_parameters`: where the paths a configuration file mentions are taken from.
+///
+/// A file whose name starts with `.rubocop` speaks about the directory holding it; any other file
+/// speaks about the directory the command ran in. The gem's own `default.yml` is the reason for the
+/// split -- its paths must not be read as relative to the gem. The dotfile in the home directory
+/// describes whatever is being inspected rather than the home directory, so it counts as an other.
+pub(super) fn path_parameter_base_directory<'a>(
+    config_path: Option<&'a Path>,
+    cwd: &'a Path,
+) -> &'a Path {
+    let home = home_directory();
+    base_directory_for(config_path, cwd, home.as_deref())
+}
+
+fn base_directory_for<'a>(
+    config_path: Option<&'a Path>,
+    cwd: &'a Path,
+    home: Option<&Path>,
+) -> &'a Path {
+    let Some(path) = config_path else {
+        return cwd;
+    };
+    let named_for_rubocop = path
+        .file_name()
+        .and_then(|name| name.to_str())
+        .is_some_and(|name| name.starts_with(".rubocop"));
+    if !named_for_rubocop || is_home_dotfile(path, home) {
+        return cwd;
+    }
+    path.parent().unwrap_or(cwd)
+}
+
+/// The configuration path is stored canonicalized, so the dotfile is compared both as written and
+/// as the file system resolves it.
+fn is_home_dotfile(path: &Path, home: Option<&Path>) -> bool {
+    home.is_some_and(|home| {
+        let dotfile = home.join(".rubocop.yml");
+        path == dotfile
+            || fs::canonicalize(&dotfile).is_ok_and(|canonical| path == canonical.as_path())
+    })
+}
+
 /// RuboCop expands `~` through `Dir.home`, which on Windows falls back to
 /// `USERPROFILE` and then `HOMEDRIVE`+`HOMEPATH` because `HOME` is normally unset
 /// there. Reading `HOME` alone hides the user-global configuration on Windows.
@@ -74,8 +116,9 @@ pub(super) fn find_project_root(start: &Path) -> Option<PathBuf> {
 #[cfg(test)]
 mod tests {
     use std::ffi::OsString;
+    use std::path::Path;
 
-    use super::resolve_home_directory;
+    use super::{base_directory_for, resolve_home_directory};
 
     fn environment<'a>(pairs: &'a [(&str, &str)]) -> impl Fn(&str) -> Option<OsString> + 'a {
         move |key| {
@@ -114,4 +157,36 @@ mod tests {
         );
         assert_eq!(resolve_home_directory(environment(&[])), None);
     }
+
+    #[test]
+    fn takes_path_parameters_from_the_directory_only_for_a_rubocop_dotfile() {
+        let cwd = Path::new("/work/project");
+        let home = Some(Path::new("/home/dev"));
+        // Nothing loaded: the command's own directory is all there is.
+        assert_eq!(base_directory_for(None, cwd, home), cwd);
+        // `.rubocop.yml` and its siblings speak about where they sit.
+        assert_eq!(
+            base_directory_for(Some(Path::new("/work/project/ci/.rubocop.yml")), cwd, home),
+            Path::new("/work/project/ci")
+        );
+        assert_eq!(
+            base_directory_for(
+                Some(Path::new("/work/project/.rubocop_todo.yml")),
+                cwd,
+                home
+            ),
+            Path::new("/work/project")
+        );
+        // Any other name is read against the directory the command ran in, so a configuration kept
+        // outside the project does not drag the target Ruby version out of its own neighbourhood.
+        assert_eq!(
+            base_directory_for(Some(Path::new("/tmp/checks/all609.yml")), cwd, home),
+            cwd
+        );
+        // The dotfile in the home directory describes the project, not the home directory.
+        assert_eq!(
+            base_directory_for(Some(Path::new("/home/dev/.rubocop.yml")), cwd, home),
+            cwd
+        );
+    }
 }