rigortype 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5c87db4b1ce8d734a2c7f8d7f0b7af6a7d643612f011c08676a5bca123ae4cb
-  data.tar.gz: b9340fe30f78245443d61d82965e08f2833e4787b938886f8f42890981a88cff
+  metadata.gz: a23952ba800fa7d807c8b8acc4d1cfbb3489024d91c3c30d687ebfdb75c7d1f5
+  data.tar.gz: 1a301a820c1c0bd3c2946695ae59f8e00906d1ecebedc0fbfb1fa93da3f6a72a
 SHA512:
-  metadata.gz: 94cafd68574caa752869465bcbf8a8e646bf302f4c540f9eb3dee122b6d455c193a21dd2debbf2c481f1676fb4c83aca131a3ba73508fef65c3dd1f2a3debaaa
-  data.tar.gz: f762d58ad77bd3e819f346b6de84408769320d6025030737b3611ce918db4c5e7943e0371b9b0603c27c2be8b8d2064975ff1e2bb113b4e3af8443bb2723fd05
+  metadata.gz: 6574512ee06d1eb87e42f697d7261eac8ecf9bba9ae4a8a4be6263fba188de5b9786babdcef7e9b2cf41ac4877010726d60f66b741af7b5295d6d3e98e5937cb
+  data.tar.gz: d1bcccf23cac521597657aadd2f1c35d7a860998dd3fc8e02a7802c2dc0e9bf23ca3c0e6c368cdb9574cc1ac1e5ff2395f9dd5f164beae13541874d617886b19

data/README.md

@@ -4,20 +4,25 @@
 [![GitHub License](https://img.shields.io/github/license/rigortype/rigor)](https://github.com/rigortype/rigor/blob/master/LICENSE)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/rigortype/rigor)
 
-**Type-aware bug finding for Ruby — zero annotations, and a
-zero-false-positive bar enforced against real codebases.** Run one
-command over the code you already have, and trust every line of
-output.
+**Type-aware bug finding for Ruby — no annotations required, and a
+zero-false-positive bar enforced against real codebases.** Built on
+RBS: Rigor infers types from the values your code produces, reads any
+RBS you write as an authoritative source, and generates more — but
+needs none to start. Run one command over the code you already have,
+and trust every line of output.
 
 ```sh
-gem install rigortype && rigor check app lib
+mise use -g ruby@4.0 gem:rigortype   # install the tool, globally, on Ruby 4.0
+rigor check app lib                  # find bugs in the code you already have
 ```
 
-(The tool itself runs on Ruby 4.0; your project can stay on whatever
-Ruby it targets — see [Get started](#get-started-in-one-prompt).)
+(The tool runs on Ruby 4.0 while your project keeps its own Ruby; the
+global `-g` install keeps it off your project's pins. See
+[Get started](#get-started-in-one-prompt).)
 
-No type annotations to write or maintain, no runtime dependency, no
-changes to your code. Rigor parses Ruby with
+No annotations required, no runtime dependency, no changes to your
+code — and any RBS you do add, Rigor reads and uses. Rigor parses Ruby
+with
 [Prism](https://github.com/ruby/prism) and runs a flow-sensitive
 inference engine that reasons about the *values* your expressions
 produce — not just their classes. It catches undefined methods (and
@@ -106,13 +111,14 @@ Bahasa Indonesia, Polski, Українська, Русский, Română, Türk
 the [installation guide](https://rigor.typedduck.fail/reference/manual/01-installation/#set-up-in-your-language).
 
 **Manual install** — Rigor is a tool, not a library: install it
-independently, **not** in your project's `Gemfile`. It runs on Ruby
-4.0 regardless of which Ruby your project targets
-([`mise`](https://mise.jdx.dev/) provisions both, pinned per project):
+independently, **not** in your project's `Gemfile`. Install it
+**globally** so `rigor` is on your `PATH` everywhere, running on Ruby
+4.0 while each project keeps its own Ruby — the `-g` install lives in
+your global [`mise`](https://mise.jdx.dev/) config and never touches a
+project's pins:
 
 ```sh
-mise use ruby@4.0
-mise use gem:rigortype     # or: gem install rigortype
+mise use -g ruby@4.0 gem:rigortype     # or: gem install rigortype
 ```
 
 The gem is named `rigortype` (the name `rigor` was taken on RubyGems);
@@ -202,14 +208,38 @@ walks the whole type model; the
 and [user manual](https://rigor.typedduck.fail/reference/manual/) are
 the reference companions.
 
+**Stuck on Rigor — or just curious how it works? Ask your agent in
+plain language.** The whole skill surface collapses to two an agent (and
+you) need to remember: **`rigor-next-steps`** ("what should we do
+next?") and **`rigor-ask`** ("answer this about Rigor"). Rigor is niche
+and fast-moving, so a model's *remembered* answer is often stale —
+`rigor-ask` **investigates instead**: it reads Rigor's own handbook and
+manual (bundled in the gem, served **offline** by `rigor docs`, always
+matching your installed version) *and* runs Rigor over your actual code
+(`rigor check` / `annotate` / `type-of`), then answers from what it
+found — citing the page, or the inferred type. Ask *"why is this
+flagged?"*, *"how does narrowing work?"*, *"how is it different from
+Sorbet?"*, *"does it handle Sidekiq?"*, or *"how do I type this
+method?"* — you only have to remember the question, never the command.
+To browse the docs yourself:
+
+```sh
+rigor docs                        # the offline doc index
+rigor docs handbook/03-narrowing  # any handbook or manual page by name
+rigor docs --list                 # list every bundled page
+```
+
 ## Status
 
-Current release: **`v0.1.18`** (2026-06-11), with `v0.2.0` — the first
-evaluation release — landing shortly. Rigor analyses real Ruby today:
-the `0.1.x` line has been hardened against Mastodon, Redmine, and
-GitLab FOSS, and the deliberately conservative rule catalogue grows
-only as fast as the zero-false-positive bar allows. Release history:
-[`CHANGELOG.md`](CHANGELOG.md) · forward-looking commitments:
+Current release: **`v0.2.0`** (2026-06-17) — the first
+publicly-announced (general / evaluation) release. It publishes an
+enumerated [compatibility surface](docs/compatibility.md) as a
+minor-non-break trial, rehearsing the contract that hard-freezes at
+`v1.0.0`. Rigor analyses real Ruby today: it has been hardened against
+Mastodon, Redmine, and GitLab FOSS, and the deliberately conservative
+rule catalogue grows only as fast as the zero-false-positive bar
+allows. Release history: [`CHANGELOG.md`](CHANGELOG.md) ·
+forward-looking commitments:
 [Roadmap](https://rigor.typedduck.fail/reference/roadmap/).
 
 ## Contributing
@@ -221,3 +251,35 @@ contributors should read.
 ## License
 
 Mozilla Public License Version 2.0. See [`LICENSE`](LICENSE).
+
+## Sponsors
+
+Rigor is built and maintained by one person, who has spent the better
+part of the last month — nearly every spare hour of personal time — on
+this project. Sustainable development depends on sustainable funding.
+
+**The current monthly budget is well short of the $200 minimum needed
+to keep this pace going; $600 or more would let me work on it
+properly.** If Rigor is saving you time or catching real bugs, please
+consider contributing:
+
+- **GitHub Sponsors**: [github.com/sponsors/zonuexe](https://github.com/sponsors/zonuexe)
+- **FANBOX** (credit-card / PayPal): [tadsan.fanbox.cc](https://tadsan.fanbox.cc/)
+
+**For individuals** — any amount is welcome and genuinely appreciated.
+Even a small recurring pledge (think of it as buying me one coffee a
+month) makes a difference when it adds up across many users.
+
+**For companies** using Rigor in production — please consider a
+contribution that reflects the engineering hours Rigor is saving you.
+A modest business sponsorship goes a long way toward keeping this
+project alive and actively maintained.
+
+**Sponsors at $50/month or more** are listed here with a banner.
+*(This threshold will likely move to $100/month at some point — early
+sponsors lock in the lower bar.)*
+
+To the sponsors who have already contributed: **thank you sincerely.**
+Your support makes the difference between a project that stalls and
+one that ships.
+

data/data/core_overlay/numeric.rbs

@@ -0,0 +1,33 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# This directory holds Rigor-owned reopenings of Ruby core classes that
+# add methods upstream `ruby/rbs` does not declare on a class but which
+# every concrete value of that class answers at runtime. It is loaded
+# LAST into the RBS environment (after core + stdlib + vendored gem
+# sigs), so an upstream declaration always wins on conflict — these
+# entries only fill genuine holes.
+#
+# Provenance: hand-authored against the documented CRuby behaviour, not
+# extracted. Keep each addition justified by an observed false positive.
+#
+# --- Numeric coercion methods ---
+#
+# `ruby/rbs`'s `Numeric` declares only `to_c` and `to_int`; the three
+# value-coercion selectors `to_f` / `to_i` / `to_r` are declared solely
+# on the concrete subclasses (`Integer`, `Float`, `Rational`, `Complex`).
+# But Rigor routinely *widens* an arithmetic chain to the abstract
+# `Numeric` nominal — `Complex#abs -> Numeric`, or an overload join over
+# `Integer | Float` — and the instant a widened value is asked for
+# `.to_f`, dispatch misses and `call.undefined-method` fires on plain,
+# correct arithmetic (observed four times across actionview's
+# `date_helper`: `(distance_in_minutes.to_f / 60.0)`).
+#
+# Every concrete `Numeric` responds to all three, so the widening must
+# not strip the capability. Returns mirror the concrete subclass
+# signatures. `to_int` is already upstream and intentionally not
+# duplicated here.
+class Numeric
+  def to_f: () -> Float
+  def to_i: () -> Integer
+  def to_r: () -> Rational
+end

data/data/core_overlay/pathname.rbs

@@ -0,0 +1,25 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- Pathname#expand_path ---
+#
+# Upstream `ruby/rbs` declares `Pathname#expand_path` as:
+#
+#   def expand_path: (?String dir) -> Pathname
+#
+# But `Pathname#expand_path` delegates to `File.expand_path`, whose `dir`
+# parameter is typed as `path` (= `string | _ToPath`). Passing a `Pathname`
+# as the base directory is the idiomatic Bundler pattern:
+#
+#   Pathname.new(path).expand_path(Bundler.root)   # root → Pathname
+#
+# With the ADR-57 self-call adoption gate now resolving `Bundler.root` to
+# `Pathname`, all five call sites in bundler.rb / bundler/source/git.rb fire
+# `argument type mismatch at parameter 'dir'`.  The upstream sig is simply
+# under-typed: the runtime accepts any `to_path`-bearing object.
+#
+# The overlay widens `dir` to `String | Pathname`, matching the runtime
+# delegation and the `File.expand_path` `path` alias used elsewhere in RBS.
+class Pathname
+  def expand_path: (?String | Pathname dir) -> Pathname
+                 | ...
+end

data/data/core_overlay/string_scanner.rbs

@@ -0,0 +1,28 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- StringScanner#[] ---
+#
+# The pinned `rbs` gem (4.0.2) declares `StringScanner#[]` as only:
+#
+#   def []: (Integer) -> String?
+#
+# But `StringScanner#[]` also accepts a capture-group *name* — a `String`
+# or `Symbol` — and returns the named capture from the most recent match.
+# Named-capture access (`scanner[:key]`) is the idiomatic form when the
+# scan pattern uses named groups:
+#
+#   scanner.skip(/(?<key>\w+)=/)
+#   scanner[:key]   # => the captured String, or nil
+#
+# Newer `ruby/rbs` already widens the signature to
+# `(Integer | String | Symbol) -> String?`; the pinned 4.0.2 gem lags.
+# Without the wider overload, a named-capture access such as Mastodon's
+# `scanner[:key]` false-fires `call.argument-type-mismatch` (the lone
+# overload rejects a `Symbol`).
+#
+# The overlay supplies the runtime-accurate overload; drop it once the
+# pinned `rbs` gem carries the wider signature.
+class StringScanner
+  def []: (Integer | String | Symbol) -> String?
+        | ...
+end