rigortype 0.2.7 → 0.2.8

data/plugins/rigor-rspec-rails/lib/rigor/plugin/rspec_rails.rb

@@ -6,49 +6,36 @@ require_relative "rspec_rails/have_http_status_analyzer"
 
 module Rigor
   module Plugin
-    # rigor-rspec-rails — validates rspec-rails matchers whose
-    # arguments are statically checkable.
+    # rigor-rspec-rails — validates rspec-rails matchers whose arguments are statically checkable.
     #
     # v0.1.0 covers `have_http_status(int_or_symbol)`:
     #
     # - Integer: must be in `100..599`.
-    # - Symbol: must be one of the
-    #   `Rack::Utils::SYMBOL_TO_STATUS_CODE` keys or one of
-    #   Rails' status-group aliases (`:success`, `:successful`,
-    #   `:missing`, `:redirect`, `:error`, `:client_error`,
+    # - Symbol: must be one of the `Rack::Utils::SYMBOL_TO_STATUS_CODE` keys or one of Rails' status-group
+    #   aliases (`:success`, `:successful`, `:missing`, `:redirect`, `:error`, `:client_error`,
     #   `:server_error`, `:informational`).
     #
     # ## Why this is a separate plugin from rigor-rspec
     #
-    # `rigor-rspec` handles the **type-narrowing** matchers
-    # (`be_a`, `be_kind_of`, `be_nil`, `eq(literal)`, etc.) —
-    # ones that refine a local's static type so downstream
-    # calls in the same `it` body resolve at the narrowed
-    # type. `rigor-rspec-rails` handles the **behavioral**
-    # matchers — ones that assert runtime state (HTTP status,
-    # rendered template, route shape) without narrowing a
-    # type. The two are activated independently in `.rigor.yml`.
+    # `rigor-rspec` handles the **type-narrowing** matchers (`be_a`, `be_kind_of`, `be_nil`, `eq(literal)`,
+    # etc.) — ones that refine a local's static type so downstream calls in the same `it` body resolve at
+    # the narrowed type. `rigor-rspec-rails` handles the **behavioral** matchers — ones that assert runtime
+    # state (HTTP status, rendered template, route shape) without narrowing a type. The two are activated
+    # independently in `.rigor.yml`.
     #
     # ## Deferred matchers
     #
-    # - `render_template(...)` — overlaps with
-    #   `rigor-actionpack`'s render-target validation
-    #   (`render :show` against the view tree). A separate
-    #   slice would coordinate the two to avoid
-    #   double-firing.
-    # - `route_to(...)` / `redirect_to(...)` — needs the
-    #   routes table from `rigor-rails-routes`
+    # - `render_template(...)` — overlaps with `rigor-actionpack`'s render-target validation (`render
+    #   :show` against the view tree). A separate slice would coordinate the two to avoid double-firing.
+    # - `route_to(...)` / `redirect_to(...)` — needs the routes table from `rigor-rails-routes`
     #   (`:helper_table` cross-plugin fact). Future slice.
-    # - `have_enqueued_job(JobClass)` /
-    #   `have_enqueued_mail(MailerClass)` — class-existence
-    #   check overlaps with engine's
-    #   `inference.unresolved-constant`; queued behind a
-    #   decision on which surface owns the diagnostic.
-    # - `have_received(:method)` — overlaps with engine's
-    #   `call.undefined-method`; same coordination question.
+    # - `have_enqueued_job(JobClass)` / `have_enqueued_mail(MailerClass)` — class-existence check overlaps
+    #   with engine's `inference.unresolved-constant`; queued behind a decision on which surface owns the
+    #   diagnostic.
+    # - `have_received(:method)` — overlaps with engine's `call.undefined-method`; same coordination
+    #   question.
     # - `be_routable` — needs routes table.
-    # - `match_response_schema(...)` (rswag / OpenAPI) — out
-    #   of scope, separate plugin.
+    # - `match_response_schema(...)` (rswag / OpenAPI) — out of scope, separate plugin.
     class RspecRails < Rigor::Plugin::Base
       manifest(
         id: "rspec-rails",
@@ -56,10 +43,9 @@ module Rigor
         description: "Validates rspec-rails behavioral matchers (have_http_status floor)."
       )
 
-      # ADR-37 — the engine walks each file and hands us every
-      # CallNode; the analyzer is now pure per-node logic. The
-      # diagnostic points at the matcher name (`message_loc`),
-      # reproducing the previous `message_loc || location` positioning.
+      # ADR-37 — the engine walks each file and hands us every CallNode; the analyzer is now pure per-node
+      # logic. The diagnostic points at the matcher name (`message_loc`), reproducing the previous
+      # `message_loc || location` positioning.
       node_rule Prism::CallNode do |node, _scope, path|
         violation = HaveHttpStatusAnalyzer.violation_for(node)
         next [] unless violation

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers/analyzer.rb

@@ -5,17 +5,13 @@ require "prism"
 module Rigor
   module Plugin
     class ShouldaMatchers < Rigor::Plugin::Base
-      # Walks every `RSpec.describe <ModelConst> do ... end` /
-      # `describe <ModelConst> do ... end` block and validates
-      # the shoulda-matchers calls inside its body (any depth
-      # of nested `describe` / `context`) against the
-      # `:model_index` published by `rigor-activerecord`.
+      # Walks every `RSpec.describe <ModelConst> do ... end` / `describe <ModelConst> do ... end` block and
+      # validates the shoulda-matchers calls inside its body (any depth of nested `describe` / `context`)
+      # against the `:model_index` published by `rigor-activerecord`.
       #
-      # The "anchor" for cross-checking is the OUTERMOST
-      # describe block whose argument is a constant — that
-      # constant names the model being specced. Nested
-      # `describe ".some_method"` (String / Symbol args) does
-      # NOT change the anchor.
+      # The "anchor" for cross-checking is the OUTERMOST describe block whose argument is a constant —
+      # that constant names the model being specced. Nested `describe ".some_method"` (String / Symbol
+      # args) does NOT change the anchor.
       #
       # ## Recognised matcher calls (v0.1.0)
       #
@@ -34,8 +30,7 @@ module Rigor
       #   have_db_column(:col)
       #   have_db_index(:col)
       #
-      # All look up `:col` against the model's columns
-      # (`Entry#column?`). Unknown columns fire
+      # All look up `:col` against the model's columns (`Entry#column?`). Unknown columns fire
       # `unknown-column`.
       #
       # ### Association matchers
@@ -45,19 +40,15 @@ module Rigor
       #   have_many(:assoc)           ← expects :collection
       #   have_and_belong_to_many(:assoc) ← expects :collection
       #
-      # Unknown associations fire
-      # `unknown-association`. Known
-      # associations with mismatched kind (`should belong_to(:posts)`
-      # where `:posts` is `has_many`) fire
-      # `association-kind-mismatch`.
+      # Unknown associations fire `unknown-association`. Known associations with mismatched kind (`should
+      # belong_to(:posts)` where `:posts` is `has_many`) fire `association-kind-mismatch`.
       module Analyzer
-        # One matcher violation (always `:warning`). Carries no
-        # path/location — the caller (the `node_rule` block) positions it
-        # at the matcher name (`message_loc`) via `Plugin::Base#diagnostic`.
+        # One matcher violation (always `:warning`). Carries no path/location — the caller (the
+        # `node_rule` block) positions it at the matcher name (`message_loc`) via `Plugin::Base#diagnostic`.
         Violation = Struct.new(:rule, :message, keyword_init: true)
 
-        # `(matcher_name) => (:column | :association_singular | :association_collection)`
-        # — the validation lane each matcher routes to.
+        # `(matcher_name) => (:column | :association_singular | :association_collection)` — the
+        # validation lane each matcher routes to.
         MATCHER_TABLE = {
           # Column matchers — validate the named column exists on the model.
           validate_presence_of: :column,
@@ -72,8 +63,7 @@ module Rigor
           validate_confirmation_of: :column,
           have_db_column: :column,
           have_db_index: :column,
-          # Association matchers — validate the association
-          # exists AND its kind matches the matcher.
+          # Association matchers — validate the association exists AND its kind matches the matcher.
           belong_to: :association_singular,
           have_one: :association_singular,
           have_many: :association_collection,
@@ -84,17 +74,13 @@ module Rigor
 
         # @param path [String]
         # @param root [Prism::Node]
-        # @param model_index [Object, nil] the `:model_index`
-        #   fact value. When nil the analyzer falls silent.
+        # @param model_index [Object, nil] the `:model_index` fact value. When nil the analyzer falls silent.
         # @return [Array<Diagnostic>]
-        # The matcher violations for a single call node (0..1), or `[]`
-        # when it is not a shoulda matcher, sits outside any
-        # `describe <ModelConst>` block, or the model is unknown.
-        # ADR-37: the engine owns the walk; the model anchor comes from
-        # the node-rule `NodeContext` ancestors (the innermost enclosing
-        # `describe`-with-constant — nested const describes override,
-        # `describe ".method"` string blocks inherit), exactly as the
-        # former recursive anchor propagation did.
+        # The matcher violations for a single call node (0..1), or `[]` when it is not a shoulda matcher,
+        # sits outside any `describe <ModelConst>` block, or the model is unknown. ADR-37: the engine owns
+        # the walk; the model anchor comes from the node-rule `NodeContext` ancestors (the innermost
+        # enclosing `describe`-with-constant — nested const describes override, `describe ".method"`
+        # string blocks inherit), exactly as the former recursive anchor propagation did.
         #
         # @param matcher_call [Prism::Node]
         # @param ancestors [Array<Prism::Node>]
@@ -114,20 +100,17 @@ module Rigor
           violation ? [violation] : []
         end
 
-        # The model anchor in effect at a node: the constant named by the
-        # innermost enclosing `describe <Const> do … end`, or nil.
+        # The model anchor in effect at a node: the constant named by the innermost enclosing `describe
+        # <Const> do … end`, or nil.
         def anchor_for(ancestors)
           describe = ancestors.rfind { |n| describe_with_constant?(n) }
           describe && describe_const_name(describe)
         end
 
-        # A direct matcher invocation is a `CallNode` whose
-        # `name` is in `MATCHER_TABLE` and whose first argument
-        # is a `SymbolNode`. The chain shape (`should`,
-        # `expect(...).to`, `is_expected.to`) is irrelevant —
-        # we always recurse to the inner matcher, so a
-        # diagnostic fires on the matcher regardless of the
-        # surrounding chain.
+        # A direct matcher invocation is a `CallNode` whose `name` is in `MATCHER_TABLE` and whose first
+        # argument is a `SymbolNode`. The chain shape (`should`, `expect(...).to`, `is_expected.to`) is
+        # irrelevant — we always recurse to the inner matcher, so a diagnostic fires on the matcher
+        # regardless of the surrounding chain.
         def matcher_invocation?(node)
           node.is_a?(Prism::CallNode) && MATCHER_TABLE.key?(node.name) && symbol_first_arg?(node)
         end
@@ -137,10 +120,8 @@ module Rigor
           !args.empty? && args.first.is_a?(Prism::SymbolNode)
         end
 
-        # Detects `RSpec.describe(Const) do ... end` and
-        # `describe(Const) do ... end`. Either form opens a
-        # scope whose anchor is `Const`. The receiver shape
-        # (RSpec vs nil) is allowed in both cases.
+        # Detects `RSpec.describe(Const) do ... end` and `describe(Const) do ... end`. Either form opens a
+        # scope whose anchor is `Const`. The receiver shape (RSpec vs nil) is allowed in both cases.
         def describe_with_constant?(node)
           return false unless node.is_a?(Prism::CallNode)
           return false unless node.name == :describe

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers.rb

@@ -6,18 +6,15 @@ require_relative "shoulda_matchers/analyzer"
 
 module Rigor
   module Plugin
-    # rigor-shoulda-matchers — validates shoulda-matchers
-    # matchers against the `:model_index` cross-plugin fact
-    # (ADR-9) published by `rigor-activerecord`.
+    # rigor-shoulda-matchers — validates shoulda-matchers matchers against the `:model_index` cross-plugin
+    # fact (ADR-9) published by `rigor-activerecord`.
     #
-    # The plugin walks every `RSpec.describe <ModelConst> do
-    # ... end` block and validates the matchers inside
-    # against the model's known columns / associations.
+    # The plugin walks every `RSpec.describe <ModelConst> do ... end` block and validates the matchers
+    # inside against the model's known columns / associations.
     #
     # ## Recognised matchers (v0.1.0)
     #
-    # **Column matchers** (validate the named column exists on
-    # the model):
+    # **Column matchers** (validate the named column exists on the model):
     #
     #   validate_presence_of(:col), validate_uniqueness_of(:col),
     #   validate_length_of(:col), validate_numericality_of(:col),
@@ -26,38 +23,27 @@ module Rigor
     #   validate_format_of(:col), validate_confirmation_of(:col),
     #   have_db_column(:col), have_db_index(:col)
     #
-    # **Association matchers** (validate the association exists
-    # AND its kind matches):
+    # **Association matchers** (validate the association exists AND its kind matches):
     #
     #   belong_to(:assoc), have_one(:assoc)            ← :singular
     #   have_many(:assoc), have_and_belong_to_many(:assoc) ← :collection
     #
     # ## Cross-plugin dependency
     #
-    # The plugin consumes `:model_index` from `rigor-activerecord`.
-    # When `rigor-activerecord` is NOT loaded (or hasn't
-    # published an index for the analysed model), the plugin
-    # falls silent — the cross-check is opt-in. Adding
-    # `rigor-activerecord` to `.rigor.yml` unlocks the
-    # diagnostics.
+    # The plugin consumes `:model_index` from `rigor-activerecord`. When `rigor-activerecord` is NOT
+    # loaded (or hasn't published an index for the analysed model), the plugin falls silent — the
+    # cross-check is opt-in. Adding `rigor-activerecord` to `.rigor.yml` unlocks the diagnostics.
     #
     # ## Limitations (v0.1.0)
     #
-    # - **No chained-matcher arg validation.** The chain
-    #   options on `validate_length_of(:col).is_at_most(50)`,
-    #   `validate_inclusion_of(:col).in_array([...])`,
-    #   `allow_value("foo").for(:col)`, etc. are NOT validated
-    #   (the `.is_at_most` etc. terminals are runtime-only).
-    # - **No polymorphic / through validation.** `belong_to(:user).polymorphic`,
-    #   `have_many(:posts, through: :memberships)` only check
-    #   the named association; the chain modifiers are
-    #   ignored.
-    # - **No nested-attribute matchers.** `accept_nested_attributes_for(:posts)`
-    #   not yet covered.
-    # - **No callback matchers.** `callback(:before_save).before(:save)`
-    #   would need a separate slice (overlaps with the
-    #   model_index's `callbacks` column already exposed but
-    #   no rspec-side recogniser yet).
+    # - **No chained-matcher arg validation.** The chain options on `validate_length_of(:col).is_at_most(50)`,
+    #   `validate_inclusion_of(:col).in_array([...])`, `allow_value("foo").for(:col)`, etc. are NOT
+    #   validated (the `.is_at_most` etc. terminals are runtime-only).
+    # - **No polymorphic / through validation.** `belong_to(:user).polymorphic`, `have_many(:posts,
+    #   through: :memberships)` only check the named association; the chain modifiers are ignored.
+    # - **No nested-attribute matchers.** `accept_nested_attributes_for(:posts)` not yet covered.
+    # - **No callback matchers.** `callback(:before_save).before(:save)` would need a separate slice
+    #   (overlaps with the model_index's `callbacks` column already exposed but no rspec-side recogniser yet).
     class ShouldaMatchers < Rigor::Plugin::Base
       manifest(
         id: "shoulda-matchers",
@@ -70,12 +56,10 @@ module Rigor
         ]
       )
 
-      # ADR-37 — per-matcher validation over the engine-owned walk. The
-      # model anchor (the enclosing `describe <Model>` const) comes from
-      # the node-rule NodeContext ancestors; the diagnostic points at the
-      # matcher name (message_loc). The :model_index fact (from
-      # rigor-activerecord) is read lazily via `read_fact`; without it
-      # the rule is silent.
+      # ADR-37 — per-matcher validation over the engine-owned walk. The model anchor (the enclosing
+      # `describe <Model>` const) comes from the node-rule NodeContext ancestors; the diagnostic points at
+      # the matcher name (message_loc). The :model_index fact (from rigor-activerecord) is read lazily via
+      # `read_fact`; without it the rule is silent.
       node_rule Prism::CallNode do |node, _scope, path, _fc, context|
         index = read_fact(plugin_id: "activerecord", name: :model_index)
         next [] if index.nil?

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/analyzer.rb

@@ -5,43 +5,35 @@ require "prism"
 module Rigor
   module Plugin
     class Sidekiq < Rigor::Plugin::Base
-      # Walks a parsed file's AST looking for
-      # `<WorkerClass>.perform_async(...)` /
-      # `.perform_inline(...)` / `.perform_in(time, ...)` /
-      # `.perform_at(time, ...)` calls and validates each
-      # against the {WorkerIndex}.
+      # Walks a parsed file's AST looking for `<WorkerClass>.perform_async(...)` / `.perform_inline(...)` /
+      # `.perform_in(time, ...)` / `.perform_at(time, ...)` calls and validates each against the
+      # {WorkerIndex}.
       #
       # Argument-shape rules:
       #
-      # - `perform_async` / `perform_inline` — every
-      #   argument is forwarded to `#perform`. Validate
-      #   `actual == #perform.arity`.
-      # - `perform_in(interval, ...args)` /
-      #   `perform_at(time, ...args)` — the FIRST argument
-      #   is the schedule (a Time / Integer / ActiveSupport
-      #   duration); the rest are forwarded to `#perform`.
+      # - `perform_async` / `perform_inline` — every argument is forwarded to `#perform`. Validate `actual
+      #   == #perform.arity`.
+      # - `perform_in(interval, ...args)` / `perform_at(time, ...args)` — the FIRST argument is the
+      #   schedule (a Time / Integer / ActiveSupport duration); the rest are forwarded to `#perform`.
       #   Validate `actual_args - 1 == #perform.arity`.
       module Analyzer
         # Methods that delegate to `#perform` 1:1.
         DIRECT_ENTRY_METHODS = %i[perform_async perform_inline].freeze
 
-        # Methods whose first argument is a schedule (the
-        # remaining args are forwarded to `#perform`).
+        # Methods whose first argument is a schedule (the remaining args are forwarded to `#perform`).
         SCHEDULED_ENTRY_METHODS = %i[perform_in perform_at].freeze
 
         ENTRY_METHODS = (DIRECT_ENTRY_METHODS + SCHEDULED_ENTRY_METHODS).freeze
 
-        # One worker-call observation: the kebab-case `rule`, `severity`,
-        # and human-readable `message`. Carries no path/location — the
-        # caller (the `node_rule` block) positions it via
+        # One worker-call observation: the kebab-case `rule`, `severity`, and human-readable `message`.
+        # Carries no path/location — the caller (the `node_rule` block) positions it via
         # `Plugin::Base#diagnostic`.
         Violation = Struct.new(:rule, :severity, :message, keyword_init: true)
 
         module_function
 
-        # The worker-call violations for a single call node (0..2), or
-        # `[]` when the node is not a `<Worker>.perform_*` entry call on a
-        # known worker. ADR-37: the engine owns the walk.
+        # The worker-call violations for a single call node (0..2), or `[]` when the node is not a
+        # `<Worker>.perform_*` entry call on a known worker. ADR-37: the engine owns the walk.
         #
         # @param call_node [Prism::Node]
         # @param worker_index [WorkerIndex]
@@ -77,8 +69,7 @@ module Rigor
 
         def arity_violation(call_node, entry)
           all_args = (call_node.arguments&.arguments || []).size
-          # Scheduled entries consume the first arg as the
-          # schedule; the rest are forwarded.
+          # Scheduled entries consume the first arg as the schedule; the rest are forwarded.
           forwarded_count = SCHEDULED_ENTRY_METHODS.include?(call_node.name) ? all_args - 1 : all_args
 
           if SCHEDULED_ENTRY_METHODS.include?(call_node.name) && all_args.zero?

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/worker_discoverer.rb

@@ -7,28 +7,20 @@ require_relative "worker_index"
 module Rigor
   module Plugin
     class Sidekiq < Rigor::Plugin::Base
-      # Walks the configured worker-search paths via the
-      # plugin's `IoBoundary`, parses each `.rb` file with
-      # Prism, and collects classes that `include
-      # Sidekiq::Job` (or one of the configured marker
-      # modules). For each discovered class, the discoverer
-      # also reads the `#perform` method's parameter list
-      # and computes the arity envelope.
+      # Walks the configured worker-search paths via the plugin's `IoBoundary`, parses each `.rb` file with
+      # Prism, and collects classes that `include Sidekiq::Job` (or one of the configured marker modules).
+      # For each discovered class, the discoverer also reads the `#perform` method's parameter list and
+      # computes the arity envelope.
       #
       # Limitations (intentional for v0.1.0):
       #
-      # - Only direct `include` matches against the
-      #   configured marker modules. `class MyWorker;
-      #   include Concerns::Sidekiqable; end` where
-      #   `Concerns::Sidekiqable` re-includes `Sidekiq::Job`
-      #   is NOT discovered. Add the intermediate module to
-      #   `worker_marker_modules` if needed.
-      # - The qualified class name is the lexical path
-      #   (`Admin::WelcomeWorker` for a class declared
-      #   inside `module Admin`).
-      # - `#perform` arity is read from the syntactic
-      #   parameter list. Methods built via
-      #   `define_method` are out of scope.
+      # - Only direct `include` matches against the configured marker modules. `class MyWorker; include
+      #   Concerns::Sidekiqable; end` where `Concerns::Sidekiqable` re-includes `Sidekiq::Job` is NOT
+      #   discovered. Add the intermediate module to `worker_marker_modules` if needed.
+      # - The qualified class name is the lexical path (`Admin::WelcomeWorker` for a class declared inside
+      #   `module Admin`).
+      # - `#perform` arity is read from the syntactic parameter list. Methods built via `define_method`
+      #   are out of scope.
       class WorkerDiscoverer
         def initialize(io_boundary:, search_paths:, marker_modules:)
           @io_boundary = io_boundary
@@ -101,9 +93,8 @@ module Rigor
           walk_for_workers(node.body, inner_path, &) if node.body
         end
 
-        # Returns true if the class body contains a top-level
-        # `include <Module>` call where `<Module>` matches
-        # one of the configured marker modules.
+        # Returns true if the class body contains a top-level `include <Module>` call where `<Module>`
+        # matches one of the configured marker modules.
         def includes_marker_module?(body)
           return false if body.nil?
 
@@ -137,9 +128,8 @@ module Rigor
           end
         end
 
-        # Returns the instance-side `def perform(...)` node
-        # from a class body, or `nil` when the class doesn't
-        # override `#perform`.
+        # Returns the instance-side `def perform(...)` node from a class body, or `nil` when the class
+        # doesn't override `#perform`.
         def lookup_perform_def(body)
           return nil if body.nil?
 
@@ -152,12 +142,9 @@ module Rigor
           nil
         end
 
-        # Builds a `WorkerIndex::Entry` from the discovered
-        # class's `#perform` def. When the class doesn't
-        # override `#perform`, we record an "any-arity"
-        # entry — Sidekiq itself doesn't supply a default
-        # `#perform`, so calling `perform_async` on a
-        # worker without one is the user's bug, not the
+        # Builds a `WorkerIndex::Entry` from the discovered class's `#perform` def. When the class doesn't
+        # override `#perform`, we record an "any-arity" entry — Sidekiq itself doesn't supply a default
+        # `#perform`, so calling `perform_async` on a worker without one is the user's bug, not the
         # plugin's call to flag without runtime context.
         def build_entry(class_name, perform_def)
           if perform_def.nil?

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/worker_index.rb

@@ -3,17 +3,13 @@
 module Rigor
   module Plugin
     class Sidekiq < Rigor::Plugin::Base
-      # Frozen catalogue of discovered Sidekiq worker
-      # classes keyed by qualified class name. Each entry
-      # holds the `#perform` method's arity envelope so the
-      # analyzer can validate `Worker.perform_async(...)`
-      # call sites.
+      # Frozen catalogue of discovered Sidekiq worker classes keyed by qualified class name. Each entry
+      # holds the `#perform` method's arity envelope so the analyzer can validate
+      # `Worker.perform_async(...)` call sites.
       #
-      # Uses the same `min_arity` / `max_arity` closed-range
-      # envelope as `rigor-activejob`'s `JobIndex::Entry`
-      # (`Float::INFINITY` upper bound when `*args` is present);
-      # Sidekiq workers serialize args to JSON so keyword arity
-      # is not tracked here.
+      # Uses the same `min_arity` / `max_arity` closed-range envelope as `rigor-activejob`'s
+      # `JobIndex::Entry` (`Float::INFINITY` upper bound when `*args` is present); Sidekiq workers
+      # serialize args to JSON so keyword arity is not tracked here.
       class WorkerIndex
         Entry = Data.define(:class_name, :min_arity, :max_arity) do
           def arity_label

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq.rb

@@ -8,14 +8,11 @@ require_relative "sidekiq/analyzer"
 
 module Rigor
   module Plugin
-    # rigor-sidekiq — validates `Worker.perform_async(...)`
-    # / `.perform_in(...)` / `.perform_at(...)` /
-    # `.perform_inline(...)` argument arity against the
-    # discovered `#perform` definitions.
+    # rigor-sidekiq — validates `Worker.perform_async(...)` / `.perform_in(...)` / `.perform_at(...)` /
+    # `.perform_inline(...)` argument arity against the discovered `#perform` definitions.
     #
     # Tier 3C of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
-    # Statically discovers Sidekiq workers by walking
-    # `worker_search_paths` and parsing each file with
+    # Statically discovers Sidekiq workers by walking `worker_search_paths` and parsing each file with
     # Prism — no `sidekiq` runtime dependency.
     #
     # ## Configuration
@@ -28,30 +25,19 @@ module Rigor
     #
     # ## What it checks
     #
-    # 1. **Argument arity** — `perform_async(args)` /
-    #    `perform_inline(args)` forward every argument to
-    #    `#perform`; `perform_in(t, args)` /
-    #    `perform_at(t, args)` consume the first argument
-    #    as the schedule and forward the rest. Mismatches
-    #    emit `wrong-arity`.
-    # 2. **Missing schedule** — `perform_in()` /
-    #    `perform_at()` with zero arguments emit
-    #    `missing-schedule`.
+    # 1. **Argument arity** — `perform_async(args)` / `perform_inline(args)` forward every argument to
+    #    `#perform`; `perform_in(t, args)` / `perform_at(t, args)` consume the first argument as the
+    #    schedule and forward the rest. Mismatches emit `wrong-arity`.
+    # 2. **Missing schedule** — `perform_in()` / `perform_at()` with zero arguments emit `missing-schedule`.
     #
     # ## Limitations (v0.1.0)
     #
-    # - Direct `include` matches only against the
-    #   configured marker modules. Indirect includes via a
+    # - Direct `include` matches only against the configured marker modules. Indirect includes via a
     #   custom concern are out of scope.
-    # - `#perform` arity is read from the syntactic
-    #   parameter list. `define_method` actions are out of
-    #   scope.
-    # - Required keyword arguments are not validated at
-    #   the call site (positional-only for v0.1.0). Sidekiq
-    #   serialises arguments to JSON, so keyword args are
-    #   uncommon in practice.
-    # - The schedule argument's type isn't validated (no
-    #   "is this a Time?" check); we just consume it.
+    # - `#perform` arity is read from the syntactic parameter list. `define_method` actions are out of scope.
+    # - Required keyword arguments are not validated at the call site (positional-only for v0.1.0).
+    #   Sidekiq serialises arguments to JSON, so keyword args are uncommon in practice.
+    # - The schedule argument's type isn't validated (no "is this a Time?" check); we just consume it.
     class Sidekiq < Rigor::Plugin::Base
       manifest(
         id: "sidekiq",
@@ -76,9 +62,8 @@ module Rigor
         @worker_marker_modules = Array(config.fetch("worker_marker_modules")).map(&:to_s)
       end
 
-      # File-level only: the load-error emission. The per-call arity
-      # validation runs over the engine-owned walk via the node_rule
-      # below (ADR-37). The worker index is lazily loaded + memoised by
+      # File-level only: the load-error emission. The per-call arity validation runs over the engine-owned
+      # walk via the node_rule below (ADR-37). The worker index is lazily loaded + memoised by
       # `producer_value`, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = producer_value(:worker_index)