sonicop 26.8.111-aarch64-linux → 26.8.113-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffcd9e8d5b49e4930702c201f4214fa4a3aca12d2d50c3307422488ea484fced
-  data.tar.gz: 0b25ee38f12c33914700b1f05e2628e494845ac2dc7b1c2538d2ae1ec128b4ba
+  metadata.gz: 136e1c379d405c4db2d9cb1bc865f06215d927887cf2291b87b235b0a1df5432
+  data.tar.gz: d9002980b9a8866e0092531b12089d37cc59f2d06de440614130809029051fb0
 SHA512:
-  metadata.gz: e1c2e822a493f07a7a887872dce6fbc5ee8b92aa5bb73a28d3c3b945a957da25c6baff4f3261fb4b7fa960a128faab4be59ad3a93d3668292c22364cc6ff04b5
-  data.tar.gz: 0a4aa06496d5a46b91ce0a4994d02ca969ef3c481fd9e1a6a5e136bb440f9c893dc012b97e561b4e6e7facf567ea50013f94bf8343badb16cd648429731043b0
+  metadata.gz: 79b863cb8c6ca365e1174e68f3fc9021deef4c1219cb06d21d5195e6fbf77c65899171720efb951db0a2989268826d536f80ec0de2b52e6efe0a01d8ac0395c5
+  data.tar.gz: 63fc02ecf63eb567f4be8d692791d1c6fa4be6e190faad0f4ea5cd4fea823be57d4649090759b83c63b6aa7f6506639dbdc4ccdc65d4be02a6f137a06bb3e1e4

data/CONFORMANCE.md

@@ -55,17 +55,18 @@ sonicop --force-default-config --format json
 
 ## Results
 
-The two kinds of difference are counted separately because they mean different things. A
-`Lint/Syntax` difference says the two disagree about whether a file parses, and everything else in
-that file follows from it; a difference in any other cop says the port reads the same tree and
-draws a different conclusion. Only the second is a defect in a cop.
+Three kinds of difference are counted separately because they mean different things. The set of
+files with a fatal `Lint/Syntax` offense says whether the parsers disagree about accepting a file.
+`Lint/Syntax` positions inside a file both already rejected measure diagnostic recovery, not file
+acceptance. A difference in any other cop says the port reads the same tree and draws a different
+conclusion. Only the last category is a defect in a cop.
 
 | Corpus | Excess | Missing | of which `Lint/Syntax` | Other cops | Field differences | Measured |
 |---|---:|---:|---|---:|---|---|
 | rubocop/rubocop | 0 | 0 | — | 0 | correctable ×1 | 2026-08-17 |
 | rails/rails | 0 | 0 | — | 0 | none | 2026-08-17 |
 | mastodon/mastodon | 0 | 0 | — | 0 | none | 2026-08-17 |
-| Homebrew/brew | 263 | 997 | **all of them** | **0** | none | 2026-08-17 |
+| Homebrew/brew | 263 | 997 | **all of them** | **0** | none | 2026-08-18 |
 | ruby/ruby | 142 | 585 | 117 missing, 44 excess | 92 | 5 | 2026-08-16 |
 
 The last column is per row on purpose. A single date at the top of the file would say the five were
@@ -85,14 +86,19 @@ run starts from, and `TargetRubyVersion` is only inferred from the working direc
 tools therefore fall back to the default of 2.7 (RuboCop says so itself: `Using Ruby 2.7 parser`) and
 both call `dry_run:,` — a hash value omission, valid since 3.1 — a syntax error. **Run the same corpus
 at 3.1 and both report zero `Lint/Syntax`.** What is left is not disagreement about which files parse:
-the file sets are identical, 569 on each side, and the first diagnostic in each file lands at the same
-position. Only the second and later diagnostics diverge, because the two parsers recover from the
-error differently — which is what puts offenses on both sides of the ledger rather than only on
-RuboCop's. Those are not chased; see *Known divergences*.
-
-What is checked here is that every one of the 1,260 is a `Lint/Syntax` offense, in both directions.
-What is not checked is which recovery produced which diagnostic: the 263 Sonicop reports and RuboCop
-does not have not been read one by one. They are accounted for as a class, not individually.
+the file sets are identical, 569 on each side, with no file unique to either parser. The two parsers
+recover differently after encountering invalid syntax, which puts diagnostic positions on both sides
+of the ledger rather than only on RuboCop's.
+
+All 263 Sonicop-only positions were classified mechanically, not inferred from their cop name. They
+occur in 135 of those shared syntax-error files, and every one follows a `Lint/Syntax` position that
+both tools reported in the same file. Their messages are 113 end-of-input (`$end`), 86 right
+parentheses (`tRPAREN`), 53 commas (`tCOMMA`), seven `end` keywords (`kEND`), two equals signs
+(`tEQL`), one `when` (`kWHEN`) and one identifier (`tIDENTIFIER`). Thus the former “excess” is not a
+set of valid files rejected only by Sonicop; it is the other direction of the same diagnostic-recovery
+divergence as the 997 RuboCop-only positions. Suppressing every diagnostic after Sonicop's first one
+would make the excess zero, but would also discard 1,998 positions that already match and increase the
+missing side from 997 to 2,995. That is not a conformance fix. See *Known divergences*.
 
 Much of ruby/ruby's difference is the same shape,
 with 117 of the 585 missing and 44 of the 142 excess being `Lint/Syntax` itself,
@@ -181,10 +187,10 @@ but no longer reproduces fails the test, and so does one that appears without be
 ### Error recovery after a syntax error
 
 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
-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.
+further diagnostics from the recovered state. Sonicop parses with tree-sitter and reaches different
+recovery states. On Homebrew this produces 997 RuboCop-only and 263 Sonicop-only `Lint/Syntax`
+positions: examples on the RuboCop side include `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
@@ -198,9 +204,10 @@ programs, one of which is English prose that happens to parse as Ruby — where
 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
+same first diagnostic (position and message), and 222 report an identical list end to end. In all 569,
+Sonicop's earliest source-position diagnostic is also present in RuboCop's output. The 277 files in
+between are the divergence in its purest form — the two agree on at least one error position and part
+company as recovery proceeds. 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
@@ -299,17 +306,43 @@ 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
-current list of what these corpora never exercise; the main ones are non-default configuration
-values, extension plugins, and Windows line endings. Cops that never fire contribute nothing to a
-match count, and their silence is indistinguishable from agreement.
-
-That limit is not hypothetical, and one instance is now measured. `Style/HashSyntax` defaults
-`EnforcedShorthandSyntax` to `either`, under which neither tool reports anything; the port
-implements none of the other four values, so half the cop is missing. Both the corpus runs and a
-sweep of RuboCop's own specs report agreement for it, because both run at the default. A cop can be
-half absent and still match everywhere the default reaches. Where a cop's behaviour is selected by
-configuration, this document covers the default branch only — the others are neither measured nor
-claimed.
+current list of what these corpora never exercise; the main ones are extension plugins and Windows
+line endings. Cops that never fire contribute nothing to a match count, and their silence is
+indistinguishable from agreement.
+
+Non-default configuration values used to be the largest of those gaps, and are now measured. Every
+one of the 111 cops carrying an `Enforced*` setting was switched to a non-default value at once —
+`Layout/SpaceInsideParens` to `space`, `Style/HashSyntax` to `hash_rockets` with
+`EnforcedShorthandSyntax: always`, and so on — and rubocop/rubocop re-run against RuboCop under the
+same file. Of 622,317 reference offenses, **99.99% match**, and 84 of the 96 cops that fired match
+exactly.
+
+| Cop | Offenses differing | |
+|---|---:|---|
+| `Layout/HashAlignment` | 35 | **RuboCop's own bug**, see below |
+| `Style/BlockDelimiters` | 17 | |
+| `Style/ConditionalAssignment` | 12 | |
+| `Style/MixinGrouping` | 8 | |
+| `Layout/SpaceInsideStringInterpolation` | 6 | |
+| `Style/NumericPredicate` | 5 | |
+| `Style/PercentQLiterals` | 4 | |
+| `Naming/VariableName` | 3 | |
+| `Lint/SymbolConversion` | 3 | |
+| `Layout/SpaceInsideParens` | 1 | |
+
+`Layout/HashAlignment`'s 35 are not a defect here. Under `EnforcedHashRocketStyle: separator`
+RuboCop raises `Parser::ClobberingError` on `spec/rubocop/config_loader_spec.rb` — three times, at
+`1111:35`, `1130:38` and `1217:35` — and reports nothing for the hashes it crashed on. Sonicop
+inspects them and reports. Every one of the 35 sits in that file between lines 1114 and 1234.
+Reproduce with:
+
+```bash
+rubocop -c <variants.yml> --only Layout/HashAlignment -d spec/rubocop/config_loader_spec.rb
+```
+
+One value per cop is not the whole configuration space — a cop with four supported styles is
+measured at two of them — so this is a floor, not a ceiling. It does settle the shape of the old
+limit: a cop is no longer allowed to be half absent and still count as matching.
 
 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

data/NOTICE

@@ -15,9 +15,9 @@ licence position checkable rather than remembered.
   not the attribution. An entry that is added late is an entry that was, for a
   while, undocumented in a public repository.
 
-  Known to be coming: tests/fixtures/upstream_spec_cases.jsonl, which will hold
-  input text from RuboCop's specs. It is deliberately **not** listed yet -- this
-  file describes what is here now, not what is planned.
+  That inventory is now complete for what is here. The entry that used to be
+  listed as "coming" -- the spec-derived fixtures -- has landed and is recorded
+  below with the rest.
 
 ================================================================================
 WHAT IS TAKEN
@@ -32,6 +32,18 @@ RuboCop -- https://github.com/rubocop/rubocop -- MIT
       Regenerate: scripts/sync_default_yml.sh 1.89.0
       Full text also kept at licenses/RUBOCOP.txt
 
+  tests/fixtures/upstream_spec_cases.jsonl
+  tests/fixtures/upstream_spec_divergences.jsonl
+      Input text taken out of RuboCop's own cop specs, each paired with what
+      RuboCop 1.89.0 actually reports for it. The spec text is upstream's; the
+      expectation beside it is not -- upstream was run once and its output
+      recorded, because upstream does not always behave the way its own specs
+      say. The second file holds the cases whose `-A` output does not parse as
+      Ruby, kept apart so that nothing demands this port reproduce them.
+      Regenerate: make spec-fixtures  (runs upstream once per cop; needs the
+      rubocop gem, which the test run itself does not)
+      Read by tests/spec_fixtures.rs
+
 Ruby on Rails -- https://github.com/rails/rails -- MIT
   Copyright (c) David Heinemeier Hansson
 

data/README.ja.md

@@ -32,22 +32,80 @@ CI へ最小限の変更で導入できます。
 
 ## 主な機能
 
-Bundler、Gemspec、Layout、Lint、Metrics、Migration、Naming、Security、Style の各部門の Cop を実装しています。
-一覧はバイナリ自身が正本です。
+Bundler、Gemspec、Layout、Lint、Metrics、Migration、Naming、Security、Style の各デパートメントの
+Cop を実装しています。一覧はバイナリ自身が正本です。
 
 ```bash
 # 認識済み Cop と実装状況の一覧
 sonicop --show-cops
 ```
 
-**RuboCop 1.89 の全 609 Cop を実装しています。** 本家のレジストリと名前まで一致しており、
-ただしこれは**レジストリについての主張**であって、すべての設定についての主張ではありません。
-`Style/HashSyntax` は存在し既定の届く範囲では一致しますが、`EnforcedShorthandSyntax` の
-既定以外の 4 つの値はいずれも未実装です。**Cop は半分欠けたまま、既定の届く範囲では
-一致し続けられます** — [CONFORMANCE.md](CONFORMANCE.md) の *Limits* を参照してください。
+**RuboCop 1.89 の全 609 Cop を実装しています。** 本家のレジストリと名前まで一致しています。
 `Enabled: pending` の 159 個と `Enabled: false` の 56 個も含みます。この 215 個は本家でも
-既定の実行では走らないので、`--only` で名指しするか設定で有効にしてください。本家にも
-存在しない Cop 名だけをエラーにし、必要なら `--ignore-unrecognized-cops` で続行できます。
+既定の実行では走らないので、`--only` で名指しするか設定で有効にしてください。本家に存在しない
+Cop 名を書いた場合だけエラーで止まります（`--ignore-unrecognized-cops` で続行できます）。
+
+### Cop 別の一致状況
+
+全 609 Cop を両者で有効にし、本家の spec が供給する 37,491 ケースを、それぞれの spec が
+指定した `TargetRubyVersion` で走らせて比較した結果です。**完全一致**とは、その Cop の offense が
+位置・メッセージ・重大度・修正可否まで 1 件残らず一致し、どちらにも余りがないことを指します。
+
+<!-- conformance:start -->
+| デパートメント | Cop 数 | 検証済み | 完全一致 | 相違 |
+|---|---:|---:|---:|---:|
+| Bundler | 7 | 7 | **7 ✓** | 0 |
+| Gemspec | 10 | 10 | **10 ✓** | 0 |
+| Layout | 100 | 100 | 90 | 10 |
+| Lint | 157 | 157 | 147 | 10 |
+| Metrics | 10 | 10 | **10 ✓** | 0 |
+| Migration | 1 | 1 | **1 ✓** | 0 |
+| Naming | 19 | 19 | **19 ✓** | 0 |
+| Security | 7 | 7 | **7 ✓** | 0 |
+| Style | 298 | 298 | 288 | 10 |
+| **合計** | **609** | **609** | **579** | **30** |
+<!-- conformance:end -->
+
+**先に読むべきは「検証済み」の列です。** ここで一度も発火しなかった Cop は、沈黙が一致と
+見分けられないため、訊かれないまま一致に数えられてしまいます。**609 個すべてがここで発火します**。
+それが「完全一致」の列を意味あるものにしています。
+
+そのうち 3 個は専用の run を要しました。`Lint/DeprecatedReference`・`Lint/NameTypo`・
+`Lint/UnusedPrivateMethod` は `rubydex` のプロジェクトインデックスが無ければ何も報告せず、
+gem の導入と `AllCops/UseProjectIndex` の有効化が要ります。`Lint/DeprecatedReference` は
+さらに条件があり、`@deprecated` を持つメソッドの定義クラスを**継承したクラスの中**から
+呼ぶ必要があります。本家の spec は「インデックス無しでは offense を出さない」という
+`expect_no_offenses` で始まるので「到達不能」と読みたくなりますが、そうではありません。
+
+「完全一致」を 609 にし、「相違」をゼロにすることが現在の目標です。実コードを足しても
+届きません。RuboCop が既定で無効にしている 56 Cop と、pending として出荷している Cop の多くは、
+ツリーがどれだけ大きくても素の実行では発火しないためです。そこに届くのは本家の spec が
+供給する入力の方で、`tests/fixtures/upstream_spec_capture.jsonl` に記録したケースは
+**609 Cop すべてに到達します**（実測）。走らせ方には間違えやすい点が 2 つあり、
+**どちらも失敗せずに表を縮めます**。
+
+- **`TargetRubyVersion` は入力の一部であって、全体の設定ではありません。** 2.7 に固定すると
+  `Style/ArrayIntersect`・`Naming/BlockForwarding`・`Style/ItBlockParameter` ほか 11 個が
+  そもそも発火できません。各ケースはその spec が指定した版で走らせます。
+- **ファイル名そのものを見る Cop があります。** `Bundler/*` は `Gemfile`、`Gemspec/*` は
+  `.gemspec`、`Naming/FileName` は名前自体を読みます。全ケースを `.rb` で書き出すと、
+  この 17 Cop が何にも一致しませんでした。
+
+これとは別に、2026-08-29 に本家 Cop spec から直接抽出できた 11,506 ケースを oracle で
+照合しました。本家が入力を読めなかった 226 ケースとクラッシュした 1 ケースを除き、測定できた
+範囲では Sonicop の**検出差分・訂正差分ともにゼロ**でした。この結果は上の表には加えていません。
+直接抽出できるケースが無い Cop が 51 個あり、ディレクティブ系 3 Cop は `--only` では測定不能な
+ため、この掃引だけで全 609 Cop の完全一致を証明できないからです。また、この直接掃引は各例の
+`TargetRubyVersion` をすべて再現せず、中立的な既定条件で実行しています。そのため、今回変更した
+Ruby 3.4 依存の 4 Cop は 3.4 で別途比較し、メッセージと位置が本家に完全一致することを確認しました。
+
+設定値については別に測っています。既定値でしか一致しない Cop は半分しか実装していないのと
+同じだからです。`Enforced*` 系の設定を持つ 111 Cop すべてを**既定以外の値**に倒して同じコーパスを
+流すと、**622,317 件の offense のうち 99.995% が一致**し、発火した 96 Cop のうち 85 個が完全一致です。
+残るのは 10 Cop（いずれも 17 件以下）と、本家がクラッシュして sonicop が正常に検出する 1 Cop です。
+内訳は [CONFORMANCE.md](CONFORMANCE.md) にあります。
+
+どちらの表も `scripts/conformance_table.rb` で再現できます。
 
 ## インストール
 
@@ -70,7 +128,7 @@ cargo install --git https://github.com/owayo/sonicop
 # 現在のプロジェクトを検査
 sonicop
 
-# Cop／部門を選択
+# Cop／デパートメントを指定
 sonicop --only Layout,Style/StringLiterals app spec
 
 # 安全な自動修正／全自動修正
@@ -95,6 +153,8 @@ sonicop --show-cops
 `AllCops/DisabledByDefault`、`Include`／`Exclude`、Cop ごとの `Enabled`、`Exclude`、
 `Severity`、`Safe`、`SafeAutoCorrect` と設定値に対応します。宣言されたプラグイン由来の
 Cop は「認識済み・未実装」として受理し、Ruby プラグインコード自体は実行しません。
+リモート設定のリクエストには 30 秒のネットワークタイムアウトを設け、応答は 1 件あたり
+5 MiB に制限します。
 
 ```yaml
 inherit_from: .rubocop_todo.yml
@@ -106,24 +166,30 @@ Style/StringLiterals:
   EnforcedStyle: single_quotes
 ```
 
-既存コマンドとの互換性を保つため、server/LSP/MCP、plugin、cache 系の引数も受理します。
-サーバートランスポート、Ruby プラグイン実行、キャッシュ再利用、カスタム Cop、実装済み以外の
-Cop は実行しません。
-
-そのうち大半は、その旨を出力します。`--server` / `--no-server` / `--lsp` / `--mcp` /
-`--plugin` は stderr に 1 行の注記を出します。cache 系は何も出しませんが、
-無言でよいのは片方だけです。
-
-- `--cache=false` はキャッシュを使わないことを求めるもので、sonicop はそれを満たしているため、
-  無言が正しい応答です。
-- `--cache=true` はキャッシュ再利用を求めるものですが、sonicop はこれを提供しておらず、
-  それでも無言です。
-
-Cop の設定値も後者と同じ挙動です。sonicop が実装していない設定値 — たとえば
-`Style/HashSyntax` の `EnforcedShorthandSyntax` — は**警告なしに無視されます**。
-名前を綴り間違えた設定値も同様に無視されます。つまり
+既存コマンドとの互換性を保つため、server/LSP/MCP、plugin 系の引数も受理します。
+サーバートランスポート、Ruby プラグイン実行、カスタム Cop、実装済み以外の Cop は実行しません。
+これらはその旨を出力します。`--server` / `--no-server` / `--lsp` / `--mcp` / `--plugin` は
+stderr に 1 行の注記を出します。
+
+cache 系の引数は、受理するだけでなく実際に効きます。sonicop は独自の結果キャッシュを持ち、
+検査時からサイズ・更新時刻・パーミッションのいずれも動いていないファイルには、
+保存済みのレポートをそのまま返します。
+
+- キャッシュは既定で有効です。`--cache false` で無効化できます。設定ファイルの
+  `AllCops/MaxFilesInCache: 0` でも同じです。
+- 置き場所は `--cache-root DIR` で指定します。省略時は `$XDG_CACHE_HOME/sonicop`、
+  macOS では `~/Library/Caches/sonicop`、それ以外は `~/.cache/sonicop` です。
+  `--cache-root` は `--cache false` とは併用できません。
+- 保持するレポート数の上限は `AllCops/MaxFilesInCache` で、既定は本家と同じ 20,000 件です。
+- autocorrect 実行、`--stdin`、`--profile`、`--memory` では読み書きしません。
+- 本家のキャッシュとは共有しません。形式が別物であり、書いたときとまったく同じ
+  ビルドの sonicop にしかエントリを返さないためです。
+
+無言なのは Cop の設定値のほうです。sonicop が実装していない設定値は**警告なしに無視されます**。
+名前を綴り間違えた設定値も同様です。つまり
 **offense が 0 件であることは、その設定が効いた証拠にはなりません**。
 無視された設定値と、違反の無いファイルが、同じ出力になるためです。
+どの設定値まで検証済みかは上の *Cop 別の一致状況* を参照してください。
 
 Cop の*名前*は検査されます。設定ファイルに未知の Cop 名があれば、実行はエラーで止まります。
 素通りするのは、既知の Cop の中の設定値です。
@@ -139,11 +205,13 @@ Mastodon（15,286 件）で、過剰も不足もメタデータ差もありま
 **件数だけでなくパスまで**一致します（集合として比較。どの側にも余りはありません）。
 残る差分は `Lint/Syntax` に集中しています。その大半は、本家の LALR パーサが
 構文エラーから回復して出す追加診断を tree-sitter では再現できないことによるもので、
-**これが説明するのは不足の向きだけ**です。**過剰の向きは別の問題で、未調査です** —
-Homebrew の 263 件はすべて `Lint/Syntax` であることまでは確認していますが、
-移植版だけが構文エラーと呼ぶその中身は調べていません。autocorrect は RuboCop 自身のツリーと
-Mastodon でバイト単位に一致します。この 2 つは死守ラインとして扱い、バイト一致が崩れた場合は
-既知差分ではなく退行として直します。
+診断位置の差は不足と過剰の両方に出ます。Homebrew の不足 997 件・過剰 263 件はすべて
+`Lint/Syntax` ですが、**構文エラーと判定したファイル集合は 569 対 569 で完全一致**し、
+移植版だけが拒否したファイルは 0 件です。過剰 263 件は共有エラーファイル 135 件にあり、
+すべて同じファイル内の共通診断より後ろにあるため、別の受理判定バグではなく回復後の診断位置差です。
+Homebrew を問題の構文をサポートする Ruby 3.1 として測ると、両者とも `Lint/Syntax` は 0 件になります。
+autocorrect は RuboCop 自身のツリーと Mastodon でバイト単位に一致します。この 2 つは死守ラインと
+して扱い、バイト一致が崩れた場合は既知差分ではなく退行として直します。
 
 コマンド、この数値を測ったコーパスのコミット、この種の計測が誤った結論を導く 2 つの罠は
 [CONFORMANCE.md](CONFORMANCE.md) にまとめています。
@@ -163,49 +231,63 @@ Mastodon でバイト単位に一致します。この 2 つは死守ライン
 既定の実行はどちらの群にも届きません。）
 各値は暖機後 2 回の最速値です。
 
-| コーパス | ファイル | RuboCop 並列 | Sonicop 並列 | RuboCop 単一 | Sonicop 単一 |
-|---|---:|---:|---:|---:|---:|
-| rubocop/rubocop | 1,765 | 12.71 秒 | **4.59 秒** | 42.74 秒 | **13.75 秒** |
-| mastodon/mastodon | 3,290 | 29.95 秒 | **6.48 秒** | 37.60 秒 | **15.88 秒** |
-| Homebrew/brew | 2,179 | 18.20 秒 | **4.31 秒** | 38.72 秒 | **11.67 秒** |
-| rails/rails | 3,551 | 52.55 秒 | **16.88 秒** | 162.55 秒 | **63.97 秒** |
-| ruby/ruby | 7,466 | 132.17 秒 | **43.10 秒** | 199.78 秒 | **76.07 秒** |
+| コーパス | ファイル | offense | RuboCop 並列 | Sonicop 並列 | RuboCop 単一 | Sonicop 単一 |
+|---|---:|---:|---:|---:|---:|---:|
+| rubocop/rubocop | 1,780 | 5,826 | 10.85 秒 | **1.53 秒** | 41.44 秒 | **8.96 秒** |
+| mastodon/mastodon | 3,292 | 15,293 | 22.59 秒 | **3.04 秒** | 34.74 秒 | **6.86 秒** |
+| Homebrew/brew | 2,296 | 51,527 | 13.56 秒 | **2.21 秒** | 40.36 秒 | **6.51 秒** |
+| rails/rails | 3,562 | 168,615 | 32.90 秒 | **8.84 秒** | 85.71 秒 | **19.17 秒** |
+| ruby/ruby | 7,477 | 765,975 | 86.89 秒 | **15.59 秒** | 193.59 秒 | **37.98 秒** |
 
-差は並列で 2.8〜4.6 倍、単一プロセスで 2.4〜3.3 倍と幅があり、1 コーパスでは代表できません。
+差は並列で 3.7〜7.4 倍、単一プロセスで 4.5〜6.2 倍と幅があり、1 コーパスでは代表できません。
 **単一プロセスの列を読み、並列は目安として扱ってください。** 同じ 2 つのバイナリを 1 日に
 3 回測ったところ、単一プロセスの値は毎回 16% 以内に収まったのに対し、RuboCop 自身のツリーでの
 並列の倍率は、マシンが他に何をしていたかだけで 3.3 倍から 9.2 倍まで動きました。単一プロセスは
 エンジンを測っていますが、並列はエンジンに加えて「その実行でスケジューリングがそのツリーに
 どれだけ噛み合ったか」を測っています。
 
-仕事を省いて速いわけではありません。この同じ 394 Cop について、RuboCop 自身のツリー・
-Rails・Mastodon の 3 つで**すべての offense が一致**します（計 188,812 件、どちらの側にも
-残りません）。autocorrect は前者と後者でバイト単位に一致します。
+仕事を省いて速いわけではありません。この同じ 394 Cop について、表のどのコーパスでも
+**offense の総数が一致**し、RuboCop 自身のツリーと Mastodon ではその 1 件ずつが同じ位置・
+同じメッセージ・同じ severity です。Rails は 168,615 件のうち 2 件だけ食い違います
+（Sonicop が出す `Style/CaseLikeIf` 1 件と、出さない `Metrics/AbcSize` 1 件）。
+RuboCop 自身のツリーでは 1 件の `correctable` フラグが違います。
+autocorrect は前者と後者でバイト単位に一致します。
 
-再現時に注意が必要な点が 2 つあります。RuboCop は **`--cache false` と併用すると
+再現時に注意が必要な点が 4 つあります。RuboCop は **`--cache false` と併用すると
 `--parallel` を黙って無効化します**。そのためここでの並列実行はキャッシュを有効にしたうえで
 実行ごとにキャッシュディレクトリを消しており、`--cache false --parallel` で計測すると
 単一プロセスを測ることになり差が過大に出ます。また RuboCop の既定は単一プロセス、
-Sonicop は `--no-parallel` を渡さない限り並列です。
+Sonicop は `--no-parallel` を渡さない限り並列です。そして**両方ともキャッシュを空にする**
+必要があります。Sonicop も既定でキャッシュするため、同じツリーを 2 回目に流すと自分の
+キャッシュが答えてしまい、エンジンについては何も測れません。どちらにも使い捨ての
+キャッシュディレクトリを渡してください。最後に、そのキャッシュディレクトリは**実パス**である
+必要があります。macOS の `mktemp -d` は `/var/folders/…` を返し、その `/var` は symlink なので
+RuboCop はそこを拒み、キャッシュ無しで走ってしまいます。
 
 ```bash
 # RuboCop（並列・キャッシュは毎回空・既定の全 394 Cop）
-rubocop --force-default-config --cache true --cache-root "$(mktemp -d)" \
+root=$(mktemp -d /private/tmp/bench.XXXXXX)
+rubocop --force-default-config --cache true --cache-root "$root" \
         --no-color --parallel -f quiet
 
-# Sonicop
-sonicop --force-default-config --format quiet
+# Sonicop（キャッシュは毎回空）
+sonicop --force-default-config --cache-root "$root" --format quiet
 ```
 
+キャッシュの書き込みもこの数値に含まれており、無料ではありません。索引は全 offense を
+「見つかった行のテキスト」付きで保持するため、`ruby/ruby` では 336 MB になります。
+2 回目の実行（キャッシュ命中）は `ruby/ruby` で 1.59 秒、Rails で 0.42 秒です。
+
 測定機は Apple M2（8 コア）、Ruby 4.0.6（YJIT 利用可）、RubyGems 導入の RuboCop 1.89.0。
-1 分平均のロードアベレージは、計測開始時が 4.0、終了時が 3.1 でした。**アイドル状態ではありません**。
-RuboCop 自身のツリーだけは後から単独で測り直しています（負荷 3.7 → 4.0）。1 回目はリリース
-ビルドの終わりがけに走ってしまい、値が 60% ほど高く出たためです。**負荷の違う 1 行を同じ表に
-並べることはできません**。
-両者を同じ条件で測っているため倍率は保たれますが、秒数そのものは下限ではなく、静かなマシンなら
-より速く出ます。コアを奪い合うものが動いていると両者とも膨らみ、その度合いは一致しません。それが
-並列の列があれだけ動く理由です。秒数そのものが重要なときは、他に負荷のない状態で測り、**実行の
-前後でロードアベレージを記録してください** — その情報が無い数値は、別の数値と比べられません。
+2026-08-31 に、`rubocop_rubocop` 2693129 / `mastodon_mastodon` b59ddc7 / `Homebrew_brew` b42173b /
+`rails_rails` a19f07f / `ruby_ruby` 22e4a75 の各リビジョンに対して測定しました。
+1 分平均のロードアベレージは各行の測定時点で 4.5〜7.1 で、その大半は RuboCop 自身の並列
+ワーカーです（計測する以上避けられません）。**アイドル状態ではありません。**
+各コーパスで両者を連続して同じ条件で測っているため倍率は保たれますが、秒数そのものは下限ではなく、
+静かなマシンならより速く出ます。コアを奪い合うものが動いていると両者とも膨らみ、その度合いは
+一致しません。それが並列の列があれだけ動く理由です。秒数そのものが重要なときは、他に負荷のない
+状態で測り、**実行の前後でロードアベレージを記録してください** — その情報が無い数値は、
+別の数値と比べられません。
 
 ## 開発
 
@@ -220,8 +302,8 @@ make gem     # source gem
 
 ### Cop の追加
 
-Cop は `src/rules/<部門>/<cop>.rs` の 1 ファイルで、公開するのは `check(context, offenses)` の
-1 関数だけです。登録は部門の `mod.rs` に 1 行を足します。
+Cop は `src/rules/<デパートメント>/<cop>.rs` の 1 ファイルで、公開するのは
+`check(context, offenses)` の 1 関数だけです。登録はデパートメントの `mod.rs` に 1 行を足します。
 
 ```rust
 department_rules! {
@@ -245,6 +327,12 @@ Cop ごとの全走査はファイル規模ではなく Cop 数に比例して
 `scripts/sync_default_yml.sh <rubocop-version>` で行い、由来のバージョンがファイル先頭に
 記録されます。
 
+`src/display_width_table.rs` も生成物で、コミットします。RuboCop は表示桁を
+`unicode-display_width` gem で数えるため、この表は手書きせず gem から生成しています。
+手書きの例外表は実際にずれており、NFD 分解された日本語でキャレットの本数が合わなくなっていました。
+再生成は `ruby scripts/dump_display_width.rb > src/display_width_table.rs` で行い、
+gem と Unicode のバージョンがファイル先頭に記録されます。
+
 依存更新には `depup --install` を使います。Ruby grammar は再現可能性のため `Cargo.toml` で
 fork のコミットを固定しています。
 

data/README.md

@@ -41,15 +41,76 @@ sonicop --show-cops
 ```
 
 **All 609 RuboCop 1.89 cops are implemented**, matched name for name against the upstream registry.
-That is a claim about the registry, not about every configuration: `Style/HashSyntax` is present and
-matches everywhere its default reaches, yet none of the four non-default values of its
-`EnforcedShorthandSyntax` are implemented. **A cop can be half absent and still match everywhere the
-default reaches** — see *Limits* in [CONFORMANCE.md](CONFORMANCE.md).
 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.
 
+### Cop conformance
+
+All 609 cops switched on, on both sides, over the 37,491 cases RuboCop's own specs supply, each
+run at the `TargetRubyVersion` its spec asked for. A cop counts as an **exact match** only when its
+offenses agree completely: every position, message, severity and correctable flag, with nothing
+extra on either side.
+
+<!-- conformance:start -->
+| Department | Cops | Exercised | Exact match | Diverging |
+|---|---:|---:|---:|---:|
+| Bundler | 7 | 7 | **7 ✓** | 0 |
+| Gemspec | 10 | 10 | **10 ✓** | 0 |
+| Layout | 100 | 100 | 90 | 10 |
+| Lint | 157 | 157 | 147 | 10 |
+| Metrics | 10 | 10 | **10 ✓** | 0 |
+| Migration | 1 | 1 | **1 ✓** | 0 |
+| Naming | 19 | 19 | **19 ✓** | 0 |
+| Security | 7 | 7 | **7 ✓** | 0 |
+| Style | 298 | 298 | 288 | 10 |
+| **Total** | **609** | **609** | **579** | **30** |
+<!-- conformance:end -->
+
+**Read the *Exercised* column first.** A cop nothing here made fire contributes neither way — its
+silence is indistinguishable from agreement, so it would be counted as agreement without ever
+being asked. **Every one of the 609 fires here**, which is what makes the *Exact match* column
+mean what it says.
+
+Three of them took a run of their own. `Lint/DeprecatedReference`, `Lint/NameTypo` and
+`Lint/UnusedPrivateMethod` report nothing without a `rubydex` project index, which needs the gem
+installed and `AllCops/UseProjectIndex` switched on — and `Lint/DeprecatedReference` needs more
+than that: the call has to sit inside a class inheriting the one whose method carries the
+`@deprecated` tag. Upstream's own specs open with an `expect_no_offenses` saying the cop is silent
+without the index, which is easy to read as "unreachable"; it is not.
+
+Getting *Exact match* to 609 while reducing *Diverging* to zero is the current goal. More real Ruby
+does not get there: the 56 cops RuboCop ships disabled, and much of what it ships as pending, never
+fire in a plain run however large the tree. What does reach every one of them is the input its own
+specs supply — the cases recorded in `tests/fixtures/upstream_spec_capture.jsonl` touch **609 of 609
+cops**, measured. Two things about running them are easy to get wrong, and both silently shrink the
+table rather than failing:
+
+- **`TargetRubyVersion` is part of the input, not a global.** Pinning everything at 2.7 leaves
+  `Style/ArrayIntersect`, `Naming/BlockForwarding`, `Style/ItBlockParameter` and eleven others
+  unable to fire at all. Each case is run at the version its spec asked for.
+- **The filename is what several cops inspect.** `Bundler/*` needs a `Gemfile`, `Gemspec/*` a
+  `.gemspec`, and `Naming/FileName` reads the name itself. Writing every case as `.rb` had all 17
+  of those cops matching nothing.
+
+A separate direct oracle sweep on 2026-08-29 examined 11,506 cases extractable from the upstream
+cop specs. RuboCop could not read 226 of those inputs and crashed on one; among the measurable
+cases, Sonicop had **zero detection differences and zero correction differences**. This result is
+not folded into the table above: 51 cops had no directly extractable case, and three directive cops
+cannot be measured under `--only`, so the sweep does not prove that all 609 cops are exact. The
+direct sweep also uses neutral/default conditions rather than preserving every example's
+`TargetRubyVersion`. The four Ruby 3.4-sensitive cops changed in this pass were therefore compared
+separately at 3.4, where their messages and locations matched RuboCop exactly.
+
+Configuration is measured separately, because a cop that only matches at its default value is half
+a cop. Every one of the 111 cops carrying an `Enforced*` setting was switched to a **non-default**
+value at once and the corpus re-run: **99.995% of 622,317 offenses match**, with 85 of the 96 cops
+that fired matching exactly. The residue is 10 cops of at most 17 offenses each, plus one where
+RuboCop crashes and sonicop does not; the list is in [CONFORMANCE.md](CONFORMANCE.md).
+
+Reproduce either table with `scripts/conformance_table.rb`.
+
 ## Installation
 
 ```bash
@@ -99,6 +160,8 @@ run. Local and HTTPS `inherit_from`, `inherit_gem`, `inherit_mode`,
 `AllCops/DisabledByDefault`, `Include`, and `Exclude`, plus per-cop `Enabled`, `Exclude`,
 `Severity`, `Safe`, `SafeAutoCorrect`, and cop settings are supported. Cops supplied by declared
 plugins are accepted as recognized-but-unimplemented without executing Ruby plugin code.
+Remote configuration requests use 30-second network timeouts, and each response is limited to
+5 MiB.
 
 ```yaml
 inherit_from: .rubocop_todo.yml
@@ -114,22 +177,29 @@ Style/StringLiterals:
   EnforcedStyle: single_quotes
 ```
 
-The CLI accepts RuboCop's server/LSP/MCP, plugin, and cache flags to keep existing command lines
-parse-compatible. Sonicop does not provide server transports, Ruby plugin execution, cache reuse,
-custom Ruby cops, or cops outside the implemented set.
-
-Most of those flags say so. `--server`, `--no-server`, `--lsp`, `--mcp`, and `--plugin` each print
-a one-line notice on stderr. The cache flags print nothing, and only one of them is silent for a
-good reason:
-
-- `--cache=false` asks for no caching, which sonicop already satisfies, so silence is the correct
-  answer.
-- `--cache=true` asks for cache reuse, which sonicop does not provide, and it is silent anyway.
-
-Cop settings behave like the second case. A setting sonicop does not implement — for example
-`EnforcedShorthandSyntax` under `Style/HashSyntax` — is ignored without any warning, and so is a
-setting whose name is simply misspelled. **A run that reports no offenses is therefore not evidence
-that a setting took effect**, because an ignored setting and a clean file produce the same output.
+The CLI accepts RuboCop's server/LSP/MCP and plugin flags to keep existing command lines
+parse-compatible. Sonicop does not provide server transports, Ruby plugin execution, custom Ruby
+cops, or cops outside the implemented set. Each of those flags says so: `--server`, `--no-server`,
+`--lsp`, `--mcp`, and `--plugin` print a one-line notice on stderr.
+
+The cache flags are honoured rather than merely parsed. Sonicop keeps a result cache of its own and
+serves a stored report for a file whose size, modification time and permission bits have not moved
+since it was inspected.
+
+- Caching is on by default. `--cache false` turns it off, as does `AllCops/MaxFilesInCache: 0` in a
+  configuration file.
+- `--cache-root DIR` chooses where it lives. Without it the root is `$XDG_CACHE_HOME/sonicop`, or
+  `~/Library/Caches/sonicop` on macOS, or `~/.cache/sonicop`. `--cache-root` cannot be combined
+  with `--cache false`.
+- `AllCops/MaxFilesInCache` bounds how many reports are kept, defaulting to RuboCop's 20,000.
+- Autocorrect runs, `--stdin`, `--profile` and `--memory` neither read nor write it.
+- It is not shared with RuboCop's cache: the formats are unrelated, and an entry is only served back
+  to a build of Sonicop identical to the one that wrote it.
+
+Cop settings are the silent case. A setting sonicop does not implement is ignored without
+any warning, and so is a setting whose name is simply misspelled. **A run that reports no offenses
+is therefore not evidence that a setting took effect**, because an ignored setting and a clean file
+produce the same output. *Cop conformance* above says which values have been measured.
 
 Cop *names* are checked: an unrecognised cop in a configuration file stops the run with an error.
 It is the settings inside a recognised cop that pass unvalidated.
@@ -146,9 +216,12 @@ Mastodon (15,286), with no excess, no shortfall and no metadata differences. The
 match exactly on all five — paths, not just counts, compared as sets. What remains is concentrated in
 `Lint/Syntax`. Most of it is RuboCop's
 LALR parser recovering from an error and emitting diagnostics a tree-sitter parse cannot
-reconstruct — that direction accounts for the shortfall. **The excess is a separate question and has
-not been investigated**; on Homebrew all 263 of it is `Lint/Syntax` too, but what Sonicop calls a
-syntax error there and RuboCop does not is unexamined.
+reconstruct, and the resulting position differences go in both directions. On Homebrew all 997
+missing and 263 excess positions are `Lint/Syntax`, but the **sets of files rejected as syntax
+errors are exactly the same: 569 versus 569**, with no file rejected only by Sonicop. The 263 excess
+positions occur in 135 shared syntax-error files and every one follows a diagnostic at a position
+shared by both tools, so they are recovery-position differences rather than a separate acceptance
+bug. At Ruby 3.1, which supports the syntax used there, both tools report zero `Lint/Syntax` offenses.
 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.
 
@@ -169,50 +242,62 @@ once the 159 RuboCop ships as `Enabled: pending` and the 56 it ships as `Enabled
 aside; a default run reaches neither group on either side.) Times are the fastest of two
 warmed runs.
 
-| Corpus | Files | RuboCop parallel | Sonicop parallel | RuboCop single | Sonicop single |
-|---|---:|---:|---:|---:|---:|
-| rubocop/rubocop | 1,765 | 12.71 s | **4.59 s** | 42.74 s | **13.75 s** |
-| mastodon/mastodon | 3,290 | 29.95 s | **6.48 s** | 37.60 s | **15.88 s** |
-| Homebrew/brew | 2,179 | 18.20 s | **4.31 s** | 38.72 s | **11.67 s** |
-| rails/rails | 3,551 | 52.55 s | **16.88 s** | 162.55 s | **63.97 s** |
-| ruby/ruby | 7,466 | 132.17 s | **43.10 s** | 199.78 s | **76.07 s** |
+| Corpus | Files | Offenses | RuboCop parallel | Sonicop parallel | RuboCop single | Sonicop single |
+|---|---:|---:|---:|---:|---:|---:|
+| rubocop/rubocop | 1,780 | 5,826 | 10.85 s | **1.53 s** | 41.44 s | **8.96 s** |
+| mastodon/mastodon | 3,292 | 15,293 | 22.59 s | **3.04 s** | 34.74 s | **6.86 s** |
+| Homebrew/brew | 2,296 | 51,527 | 13.56 s | **2.21 s** | 40.36 s | **6.51 s** |
+| rails/rails | 3,562 | 168,615 | 32.90 s | **8.84 s** | 85.71 s | **19.17 s** |
+| ruby/ruby | 7,477 | 765,975 | 86.89 s | **15.59 s** | 193.59 s | **37.98 s** |
 
-The gap is 2.8x to 4.6x in parallel and 2.4x to 3.3x single-process, so no single corpus summarizes
+The gap is 3.7x to 7.4x in parallel and 4.5x to 6.2x 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, on Rails and on Mastodon — 188,812 offenses with nothing on either side of the
-ledger — and autocorrect is byte-identical on the first and the last.
+The speed is not bought by skipping work. Over those same 394 cops the two find the **same number of
+offenses** on every corpus in the table, and on RuboCop's own tree and on Mastodon every one of them
+is at the same position with the same message and severity. Rails, at 168,615 offenses, differs in
+two of them — one `Style/CaseLikeIf` Sonicop reports and one `Metrics/AbcSize` it does not — and
+RuboCop's own tree differs in one offense's `correctable` flag. Autocorrect is byte-identical on the
+first and the last.
 
-Two details matter for reproducing this. RuboCop **silently turns `--parallel` off when combined
+Four 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
 run rather than disabled; timing it with `--cache false --parallel` measures a single process and
 overstates the difference. RuboCop's default is a single process, while Sonicop is parallel unless
-`--no-parallel` is passed.
+`--no-parallel` is passed. Both sides need a **cold** cache: Sonicop caches by default too, so a
+second run over the same tree answers from its own cache and measures nothing about the engine —
+give each tool a throwaway cache root. And the cache root must be a **real path**: macOS `mktemp -d`
+returns `/var/folders/…`, whose `/var` is a symlink, and RuboCop refuses such a location and runs
+with no cache at all.
 
 ```bash
 # RuboCop, parallel, cold cache, its full default set of 394 cops
-rubocop --force-default-config --cache true --cache-root "$(mktemp -d)" \
+root=$(mktemp -d /private/tmp/bench.XXXXXX)
+rubocop --force-default-config --cache true --cache-root "$root" \
         --no-color --parallel -f quiet
 
-# Sonicop
-sonicop --force-default-config --format quiet
+# Sonicop, cold cache
+sonicop --force-default-config --cache-root "$root" --format quiet
 ```
 
+Writing the cache is part of these numbers, and it is not free: the index holds every offense with
+the source line it was found on, which is 336 MB over `ruby/ruby`. A second run against a warm cache
+answers in 1.59 s there, and in 0.42 s over Rails.
+
 Machine: Apple M2 (8 cores), Ruby 4.0.6 with YJIT available, RubyGems-installed RuboCop 1.89.0.
-The one-minute load average was 4.0 when the run started and 3.1 when it finished — the machine was
-in use, not idle. RuboCop's own tree was re-measured on its own afterwards, at load 3.7 rising to 4.0,
-because the first pass over it ran while a release build was still finishing and its numbers came out
-60% high; a row measured under a different load cannot sit in the same table as the others. 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.
+Measured on 2026-08-31 against the corpora at `rubocop_rubocop` 2693129, `mastodon_mastodon` b59ddc7,
+`Homebrew_brew` b42173b, `rails_rails` a19f07f and `ruby_ruby` 22e4a75. The one-minute load average
+was between 4.5 and 7.1 as each row was taken — most of it RuboCop's own parallel workers, which is
+inherent to measuring them. **The machine was in use, not idle.** Both tools ran back to back under
+the same conditions on each corpus, 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
 
@@ -254,6 +339,13 @@ fails when the two disagree.
 `scripts/sync_default_yml.sh <rubocop-version>`, which records the source version in the file
 header.
 
+`src/display_width_table.rs` is generated and committed too. RuboCop measures display columns with
+the `unicode-display_width` gem, so the table is taken from the gem rather than restated by hand —
+an exception table written out by hand had already drifted far enough to draw the wrong number of
+carets under decomposed Japanese. Regenerate it with
+`ruby scripts/dump_display_width.rb > src/display_width_table.rs`, which records the gem and Unicode
+versions in the file header.
+
 Dependencies are updated with `depup --install`. The Ruby grammar dependency is pinned to an exact
 fork commit in `Cargo.toml` for reproducible builds.
 

data/lib/sonicop/runner.rb

@@ -15,7 +15,13 @@ module Sonicop
       MESSAGE
 
       begin
-        exec(binary, *arguments)
+        # `[binary, binary]` = exec 形式の強制。`exec(binary, *arguments)` は arguments が空、
+        # つまり「カレントディレクトリを見る素の `sonicop`」という最も普通の呼び出しのとき
+        # `exec(String)` = commandline 形式に落ちる。この形式は空白で単語分割し、メタ文字が
+        # あればまるごと /bin/sh に渡すため、binary のパス次第で ENOENT や exit 127 になる。
+        # パスの出所は SONICOP_BINARY と gem の install 先で、どちらもメタ文字を含まない保証がない。
+        # argv0 は multi-arg 形式が既定で入れるものと同じ値を明示している。
+        exec([binary, binary], *arguments)
       rescue SystemCallError => error
         # 実行できない典型は「platform gem は入ったが実行環境と ABI が違う」ケース
         # (musl 環境に glibc ビルドが入るなど)。素の errno だけでは原因が読めない。

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.111'
+  VERSION = '26.8.113'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sonicop
 version: !ruby/object:Gem::Version
-  version: 26.8.111
+  version: 26.8.113
 platform: aarch64-linux
 authors:
 - Yohei