rigortype 0.1.9 → 0.1.11

data/plugins/rigor-activesupport-core-ext/lib/rigor-activesupport-core-ext.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# rigor-activesupport-core-ext — a community-maintained RBS bundle
+# for the most-frequently-flagged ActiveSupport core extensions.
+#
+# Per ADR-25 this gem is a pure RBS-bundle *plugin*: it ships a
+# `sig/` directory and a trivial `Rigor::Plugin::Base` subclass
+# whose manifest declares `signature_paths: ["sig"]`. Activate it
+# by listing the gem under `.rigor.yml`'s `plugins:` — Rigor
+# resolves and loads the bundled `sig/` automatically, with no
+# hand-written path:
+#
+#     # .rigor.yml
+#     plugins:
+#       - rigor-activesupport-core-ext
+#
+# Coverage scope and rationale: see `README.md` in this directory
+# and `docs/notes/20260515-real-world-rails-survey.md` for the
+# survey that established the selector ranking.
+require_relative "rigor/plugin/activesupport_core_ext"

data/plugins/rigor-activesupport-core-ext/sig/active_support/core_ext.rbs

@@ -0,0 +1,463 @@
+# ActiveSupport core_ext — community-maintained RBS bundle.
+#
+# Scope: the most-frequently-flagged ActiveSupport extension methods
+# from a four-project Rails survey (Redmine, Discourse, Mastodon,
+# GitLab FOSS — see `docs/notes/20260515-real-world-rails-survey.md`).
+# Roughly the top ~40 selectors by `call.undefined-method` frequency,
+# which together account for the bulk of the Rails-extension long
+# tail.
+#
+# This file is opt-in: enable by adding the gem's `sig/` directory
+# to `.rigor.yml`'s `signature_paths:`:
+#
+#     # .rigor.yml
+#     signature_paths:
+#       - sig
+#       - path/to/rigor-activesupport-core-ext/sig
+#
+# Not exhaustive. ActiveSupport ships many more extensions across
+# Hash / Array / String / Object / Date / Time / Integer / Module
+# than this file covers; PRs welcome to extend.
+
+# ---------------------------------------------------------------
+# Object — universal predicates and helpers
+# ---------------------------------------------------------------
+
+class Object
+  # @return [bool]
+  def blank?: () -> bool
+
+  # @return [bool]
+  def present?: () -> bool
+
+  # @return [self?]
+  def presence: () -> self?
+
+  # `active_support/core_ext/object/json` monkey-patches
+  # `as_json` onto Object (default returns the object's
+  # `instance_values` hash) plus per-class overrides on
+  # NilClass / TrueClass / FalseClass / Numeric / String /
+  # Symbol / Time / Date / Array / Hash / Range / Regexp /
+  # Struct / Enumerable. Most call-site code uses the
+  # universal `obj.as_json` shape so a single Object row
+  # restores type coverage at the Mastodon-derived
+  # `as_json` call sites (`fan_out_on_write_service.rb`,
+  # `push_update_worker.rb`, `media_component_helper.rb`).
+  # `options` is the standard `only:` / `except:` / `methods:`
+  # / `include:` hash — left as untyped because the surface
+  # is large and per-call-site precision is rarely useful.
+  def as_json: (?untyped options) -> untyped
+
+  # `try` swallows NoMethodError; declared return is `untyped`
+  # because the called method's signature is not known to RBS
+  # at this call site.
+  def try: (Symbol | String) -> untyped
+         | (Symbol | String, *untyped) -> untyped
+         | (Symbol | String, *untyped) { (?) -> untyped } -> untyped
+
+  def try!: (Symbol | String) -> untyped
+          | (Symbol | String, *untyped) -> untyped
+          | (Symbol | String, *untyped) { (?) -> untyped } -> untyped
+
+  # `acts_like?(:string)` / `acts_like?(:date)` / `acts_like?(:time)`
+  # is ActiveSupport's "duck-typing helper" predicate.
+  def acts_like?: (Symbol | String) -> bool
+end
+
+# `nil.blank?` / `nil.present?` / `nil.try` are the most frequent
+# call sites the survey turned up.
+class NilClass
+  def blank?: () -> true
+  def present?: () -> false
+  def presence: () -> nil
+  def try: (*untyped) -> nil
+  def try!: (*untyped) -> nil
+end
+
+class TrueClass
+  def blank?: () -> false
+  def present?: () -> true
+end
+
+class FalseClass
+  def blank?: () -> true
+  def present?: () -> false
+end
+
+# ---------------------------------------------------------------
+# String — ActiveSupport `core_ext/string/*`
+# ---------------------------------------------------------------
+
+class String
+  # `core_ext/string/inflections`
+  def underscore: () -> String
+  def camelize: (?Symbol upper_case_first) -> String
+  def camelcase: (?Symbol upper_case_first) -> String
+  def classify: () -> String
+  def constantize: () -> untyped
+  def safe_constantize: () -> untyped
+  def demodulize: () -> String
+  def deconstantize: () -> String
+  def titleize: () -> String
+  def parameterize: (?separator: String, ?preserve_case: bool, ?locale: Symbol?) -> String
+  def tableize: () -> String
+  def foreign_key: (?bool separate_class_name_and_id_with_underscore) -> String
+  def pluralize: (?Integer count, ?Symbol locale) -> String
+  def singularize: (?Symbol locale) -> String
+  def humanize: (?capitalize: bool, ?keep_id_suffix: bool) -> String
+
+  # `core_ext/string/filters`
+  def squish: () -> String
+  def squish!: () -> String
+  def truncate: (Integer truncate_at, ?omission: String, ?separator: String | Regexp | nil) -> String
+  def truncate_bytes: (Integer truncate_at, ?omission: String) -> String
+  def truncate_words: (Integer words_count, ?omission: String, ?separator: String | Regexp | nil) -> String
+
+  # `core_ext/string/output_safety` — `html_safe` returns an
+  # `ActiveSupport::SafeBuffer` (a String subclass). The closest
+  # RBS-canonical carrier is plain `String`; precision lost is the
+  # `html_safe?` predicate value.
+  def html_safe: () -> String
+  def html_safe?: () -> bool
+
+  # `core_ext/string/indent`
+  def indent: (Integer amount, ?String indent_string, ?bool indent_empty_lines) -> String
+  def indent!: (Integer amount, ?String indent_string, ?bool indent_empty_lines) -> String?
+
+  # `core_ext/string/starts_ends_with` — also covered by core
+  # `start_with?` / `end_with?`; these are the ActiveSupport aliases.
+  def starts_with?: (*String prefixes) -> bool
+  def ends_with?: (*String suffixes) -> bool
+
+  # `core_ext/string/conversions` — `to_time` / `to_date` /
+  # `to_datetime` return Time / Date / DateTime.
+  def to_time: (?Symbol form) -> Time?
+  def to_date: () -> Date?
+  def to_datetime: () -> DateTime
+  def to_hours: () -> Float
+
+  # `core_ext/string/access`
+  def at: (Integer | Range[Integer] | Regexp position) -> String?
+  def from: (Integer position) -> String
+  def to: (Integer position) -> String
+  def first: (?Integer limit) -> String
+  def last: (?Integer limit) -> String
+
+  # `core_ext/string/strip` — leading-blank strip with shared margin.
+  def strip_heredoc: () -> String
+
+  # `core_ext/string/multibyte`
+  def mb_chars: () -> untyped
+
+  # `core_ext/string/inquiry`
+  def inquiry: () -> untyped # ActiveSupport::StringInquirer
+end
+
+# ---------------------------------------------------------------
+# Integer — `core_ext/integer/*`
+# ---------------------------------------------------------------
+
+class Integer
+  # `core_ext/numeric/time` — Duration multipliers.
+  def second: () -> untyped # ActiveSupport::Duration
+  def seconds: () -> untyped
+  def minute: () -> untyped
+  def minutes: () -> untyped
+  def hour: () -> untyped
+  def hours: () -> untyped
+  def day: () -> untyped
+  def days: () -> untyped
+  def week: () -> untyped
+  def weeks: () -> untyped
+  def fortnight: () -> untyped
+  def fortnights: () -> untyped
+  def month: () -> untyped
+  def months: () -> untyped
+  def year: () -> untyped
+  def years: () -> untyped
+
+  # `core_ext/numeric/bytes`
+  def byte: () -> Integer
+  def bytes: () -> Integer
+  def kilobyte: () -> Integer
+  def kilobytes: () -> Integer
+  def megabyte: () -> Integer
+  def megabytes: () -> Integer
+  def gigabyte: () -> Integer
+  def gigabytes: () -> Integer
+  def terabyte: () -> Integer
+  def terabytes: () -> Integer
+  def petabyte: () -> Integer
+  def petabytes: () -> Integer
+  def exabyte: () -> Integer
+  def exabytes: () -> Integer
+
+  # `core_ext/integer/multiple`
+  def multiple_of?: (Integer) -> bool
+
+  # `core_ext/integer/inflections`
+  def ordinal: () -> String
+  def ordinalize: () -> String
+end
+
+# ---------------------------------------------------------------
+# Float — same Duration / Bytes pattern as Integer
+# ---------------------------------------------------------------
+
+class Float
+  def second: () -> untyped
+  def seconds: () -> untyped
+  def minute: () -> untyped
+  def minutes: () -> untyped
+  def hour: () -> untyped
+  def hours: () -> untyped
+  def day: () -> untyped
+  def days: () -> untyped
+  def week: () -> untyped
+  def weeks: () -> untyped
+  def month: () -> untyped
+  def months: () -> untyped
+  def year: () -> untyped
+  def years: () -> untyped
+
+  def byte: () -> Float
+  def bytes: () -> Float
+  def kilobyte: () -> Float
+  def kilobytes: () -> Float
+  def megabyte: () -> Float
+  def megabytes: () -> Float
+  def gigabyte: () -> Float
+  def gigabytes: () -> Float
+end
+
+# ---------------------------------------------------------------
+# Time — singleton + instance extensions
+# ---------------------------------------------------------------
+
+class Time
+  def self.current: () -> Time
+  def self.zone: () -> untyped # ActiveSupport::TimeZone | nil
+  def self.zone=: (String | Symbol | untyped) -> untyped
+
+  # `core_ext/time/conversions` — also `Time.parse` from stdlib
+  # `time`, which is already in core RBS.
+  def self.httpdate: (String) -> Time
+  def self.iso8601: (String) -> Time
+
+  # `core_ext/time/calculations`
+  def yesterday: () -> Time
+  def tomorrow: () -> Time
+  def beginning_of_day: () -> Time
+  def end_of_day: () -> Time
+  def beginning_of_hour: () -> Time
+  def end_of_hour: () -> Time
+  def beginning_of_minute: () -> Time
+  def end_of_minute: () -> Time
+  def beginning_of_week: (?Symbol start_day) -> Time
+  def end_of_week: (?Symbol start_day) -> Time
+  def beginning_of_month: () -> Time
+  def end_of_month: () -> Time
+  def beginning_of_year: () -> Time
+  def end_of_year: () -> Time
+  def ago: (Numeric seconds) -> Time
+  def since: (Numeric seconds) -> Time
+  def in: (Numeric seconds) -> Time
+  def change: (**untyped) -> Time
+  def at_beginning_of_day: () -> Time
+  def at_end_of_day: () -> Time
+  def at_beginning_of_week: () -> Time
+  def at_end_of_week: () -> Time
+  def at_midnight: () -> Time
+  def at_noon: () -> Time
+  def midday: () -> Time
+  def midnight: () -> Time
+  def noon: () -> Time
+  def utc?: () -> bool
+  def acts_like_time?: () -> true
+end
+
+# ---------------------------------------------------------------
+# Date — `core_ext/date/*`
+# ---------------------------------------------------------------
+
+class Date
+  def self.current: () -> Date
+  def self.yesterday: () -> Date
+  def self.tomorrow: () -> Date
+  def self.beginning_of_week: () -> Date
+  def self.end_of_week: () -> Date
+  def self.beginning_of_month: () -> Date
+  def self.end_of_month: () -> Date
+  def self.beginning_of_year: () -> Date
+  def self.end_of_year: () -> Date
+
+  def yesterday: () -> Date
+  def tomorrow: () -> Date
+  def beginning_of_week: (?Symbol start_day) -> Date
+  def end_of_week: (?Symbol start_day) -> Date
+  def beginning_of_month: () -> Date
+  def end_of_month: () -> Date
+  def beginning_of_year: () -> Date
+  def end_of_year: () -> Date
+  def ago: (Numeric seconds) -> Time
+  def since: (Numeric seconds) -> Time
+  def acts_like_date?: () -> true
+end
+
+# ---------------------------------------------------------------
+# Array — singleton wrapper + instance extensions
+# ---------------------------------------------------------------
+
+class Array[unchecked out Elem]
+  # `Array.wrap(x)` is the dominant Rails idiom: `nil → []`,
+  # `Array x → x`, `else → [x]`.
+  def self.wrap: (untyped) -> Array[untyped]
+
+  # `core_ext/array/access`
+  def from: (Integer position) -> Array[Elem]
+  def to: (Integer position) -> Array[Elem]
+  def second: () -> Elem?
+  def third: () -> Elem?
+  def fourth: () -> Elem?
+  def fifth: () -> Elem?
+  def forty_two: () -> Elem?
+
+  # `core_ext/array/grouping`
+  def in_groups_of: (Integer number, ?untyped fill_with) -> Array[Array[Elem]]
+                  | (Integer number, ?untyped fill_with) { (Array[Elem]) -> void } -> Array[Elem]
+  def in_groups: (Integer number, ?untyped fill_with) -> Array[Array[Elem]]
+               | (Integer number, ?untyped fill_with) { (Array[Elem]) -> void } -> Array[Elem]
+  def split: (?untyped value) -> Array[Array[Elem]]
+           | () { (Elem) -> bool } -> Array[Array[Elem]]
+
+  # `core_ext/array/conversions`
+  def to_sentence: (?two_words_connector: String, ?last_word_connector: String, ?words_connector: String, ?locale: Symbol?) -> String
+  def to_formatted_s: (?Symbol format) -> String
+  def to_fs: (?Symbol format) -> String
+  def to_xml: (**untyped) -> String
+
+  # `core_ext/array/inquiry`
+  def inquiry: () -> untyped # ActiveSupport::ArrayInquirer
+
+  # `core_ext/array/extract`
+  def extract!: () { (Elem) -> bool } -> Array[Elem]
+
+  # `core_ext/object/blank` / `core_ext/enumerable` — both
+  # ActiveSupport additions, shipped on Array specifically.
+  def compact_blank: () -> Array[Elem]
+  def compact_blank!: () -> self
+  def exclude?: (Elem) -> bool
+end
+
+# ---------------------------------------------------------------
+# Enumerable — `core_ext/enumerable`
+# ---------------------------------------------------------------
+
+module Enumerable[unchecked out Elem]
+  def index_by: () { (Elem) -> untyped } -> Hash[untyped, Elem]
+  def index_with: (?untyped default) { (Elem) -> untyped } -> Hash[Elem, untyped]
+                | (untyped default) -> Hash[Elem, untyped]
+  def exclude?: (Elem) -> bool
+  def including: (*Elem) -> Array[Elem]
+  def excluding: (*Elem) -> Array[Elem]
+  def without: (*Elem) -> Array[Elem]
+  def pluck: (Symbol | String) -> Array[untyped]
+           | (*Symbol | String) -> Array[Array[untyped]]
+  def pick: (Symbol | String) -> untyped
+          | (*Symbol | String) -> Array[untyped]?
+  def maximum: (Symbol | String) -> untyped
+  def minimum: (Symbol | String) -> untyped
+  def sole: () -> Elem
+  def compact_blank: () -> Array[Elem]
+end
+
+# ---------------------------------------------------------------
+# Hash — `core_ext/hash/*`
+# ---------------------------------------------------------------
+
+class Hash[unchecked out K, unchecked out V]
+  # `core_ext/hash/keys`
+  def symbolize_keys: () -> Hash[Symbol, V]
+  def symbolize_keys!: () -> self
+  def deep_symbolize_keys: () -> Hash[untyped, untyped]
+  def deep_symbolize_keys!: () -> self
+  def stringify_keys: () -> Hash[String, V]
+  def stringify_keys!: () -> self
+  def deep_stringify_keys: () -> Hash[untyped, untyped]
+  def deep_stringify_keys!: () -> self
+  def assert_valid_keys: (*K | Array[K]) -> self
+  def deep_transform_keys: () { (K) -> K } -> Hash[K, untyped]
+  def deep_transform_keys!: () { (K) -> K } -> self
+  def deep_transform_values: () { (V) -> untyped } -> Hash[K, untyped]
+  def deep_transform_values!: () { (V) -> untyped } -> self
+
+  # `core_ext/hash/deep_dup`
+  def deep_dup: () -> Hash[K, V]
+
+  # `core_ext/hash/deep_merge`
+  def deep_merge: (Hash[K, V]) -> Hash[K, V]
+                | (Hash[K, V]) { (K, V, V) -> V } -> Hash[K, V]
+  def deep_merge!: (Hash[K, V]) -> self
+                 | (Hash[K, V]) { (K, V, V) -> V } -> self
+
+  # `core_ext/hash/except` — `Hash#except` is in core RBS as of
+  # Ruby 3.0+; `except!` is ActiveSupport-only.
+  def except!: (*K) -> self
+
+  # `core_ext/hash/conversions`
+  def to_query: (?String namespace) -> String
+  def to_param: (?String namespace) -> String
+  def to_xml: (**untyped) -> String
+
+  # `core_ext/hash/indifferent_access`
+  def with_indifferent_access: () -> untyped
+
+  # `core_ext/hash/conversions`
+  def self.from_xml: (String, ?Symbol disallowed_types) -> Hash[String, untyped]
+  def self.from_trusted_xml: (String) -> Hash[String, untyped]
+
+  # `core_ext/object/blank` / `core_ext/hash`
+  def compact_blank: () -> Hash[K, V]
+  def compact_blank!: () -> self
+
+  # `core_ext/hash/reverse_merge`
+  def reverse_merge: (Hash[K, V]) -> Hash[K, V]
+  def reverse_merge!: (Hash[K, V]) -> self
+
+  # `core_ext/hash/slice` — `Hash#except` is in core RBS (Ruby 3.0+);
+  # `Hash#slice` is in core RBS (Ruby 2.5+); the bang variants are
+  # ActiveSupport-only.
+  def slice!: (*K) -> Hash[K, V]
+end
+
+# ---------------------------------------------------------------
+# DateTime — `core_ext/date_time/*`
+# ---------------------------------------------------------------
+
+class DateTime
+  def utc: () -> Time
+  def to_time: () -> Time
+  def in_time_zone: (?String | Symbol zone) -> untyped
+  def yesterday: () -> DateTime
+  def tomorrow: () -> DateTime
+  def ago: (Numeric seconds) -> DateTime
+  def since: (Numeric seconds) -> DateTime
+  def beginning_of_day: () -> DateTime
+  def end_of_day: () -> DateTime
+  def beginning_of_hour: () -> DateTime
+  def end_of_hour: () -> DateTime
+  def beginning_of_minute: () -> DateTime
+  def end_of_minute: () -> DateTime
+  def acts_like_time?: () -> true
+end
+
+# ---------------------------------------------------------------
+# String — `core_ext/string/exclude` (an ActiveSupport addition)
+# ---------------------------------------------------------------
+
+# (Re-opens String to add `#exclude?`. Listed here rather than in the
+# main String block above because it's a less-common method whose
+# coverage was added after a second-round survey.)
+class String
+  def exclude?: (String) -> bool
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # ADR-16 Tier B worked plugin: recognises Devise's model-side
+    # `devise :strategy_a, :strategy_b` DSL on `ActiveRecord::Base`
+    # subclasses and explodes each strategy's module RBS into the
+    # calling class.
+    #
+    # Per the per-library survey (§ Devise), Devise's `devise(*modules)`
+    # at `lib/devise/models.rb:79-112` is a **table-driven include
+    # sequence**: each Symbol argument resolves through
+    # `Devise::Models.const_get(m.to_s.classify)` to a concrete
+    # `Devise::Models::*` module, which is then mixed into the
+    # calling class. The substrate replays the same shape
+    # statically — the manifest's `modules_by_symbol:` mirrors
+    # Devise's `lib/devise/modules.rb` and the pre-pass scanner
+    # synthesises one SyntheticMethod per (calling class, included
+    # module instance method) pair into the SyntheticMethodIndex.
+    #
+    # ## Reach
+    #
+    # The full set of strategies Devise registers via
+    # `Devise.add_module` at gem load (per `lib/devise/modules.rb`):
+    #
+    # - `:database_authenticatable` — password + email auth core
+    # - `:recoverable` — password-reset flow
+    # - `:rememberable` — persistent cookies
+    # - `:registerable` — sign-up + account-edit flow
+    # - `:trackable` — sign-in count / last-IP / last-at
+    # - `:validatable` — email + password validations
+    # - `:confirmable` — email confirmation flow
+    # - `:lockable` — account-lock-after-failed-attempts
+    # - `:timeoutable` — automatic logout after idle
+    # - `:omniauthable` — OmniAuth providers
+    # - `:authenticatable` — always-included base module
+    #
+    # The substrate's pre-pass scanner consults each module's RBS
+    # via `Environment::RbsLoader#instance_definition` to enumerate
+    # method names. A user project providing real Devise via
+    # Bundler will see methods like `valid_password?`,
+    # `send_reset_password_instructions`, etc. resolve through the
+    # synthetic-method tier without `call.undefined-method`.
+    #
+    # ## Floor / ceiling per ADR-16 WD13
+    #
+    # Slice 3 ships at the **floor**: synthesised method names
+    # emit and the dispatcher's `try_synthetic_method` tier
+    # returns `Type::Combinator.untyped` (Dynamic[T]) for every
+    # match. Per the slice-3 design judgment (1) the precision
+    # promotion — looking up the module's authored RBS return
+    # type at dispatch time — is **slice-6 ceiling work** and is
+    # NOT a delivery commitment of slice 3c. The `origin_module:`
+    # provenance field is recorded so the ceiling slice can
+    # promote without rescanning.
+    #
+    # ## Scope (slice 3c minimum)
+    #
+    # - Recognises model-side `devise :a, :b` on any AR::Base
+    #   subclass; trait symbol set mirrors `lib/devise/modules.rb`.
+    # - `Devise::Models::Authenticatable` is always_included
+    #   (matches Devise's `with_options model: true`).
+    # - Unknown trait symbols silently skipped (per slice-3
+    #   design judgment (2)). User initializers that call
+    #   `Devise.add_module :my_strategy, ...` are NOT seen — that
+    #   path requires a separate scanner for `config/initializers/`
+    #   and is deferred.
+    # - Controller-side helpers (`current_user`, `authenticate_user!`,
+    #   etc.) are Tier C work, NOT Tier B; deferred to a future
+    #   slice that consumes ADR-9 fact-store entries from a
+    #   `rigor-rails-routes`-style walker.
+    # - Per-strategy `ClassMethods` extend (Devise's `extend
+    #   Mod::ClassMethods` pattern) is NOT yet wired — slice 3
+    #   covers instance methods only per WD13 floor.
+    class Devise < Rigor::Plugin::Base
+      manifest(
+        id: "devise",
+        version: "0.1.0",
+        description: "Recognises Devise's `devise :strategy` DSL via ADR-16 Tier B.",
+        trait_registries: [
+          Rigor::Plugin::Macro::TraitRegistry.new(
+            receiver_constraint: "ActiveRecord::Base",
+            method_name: :devise,
+            symbol_arg_position: :rest,
+            modules_by_symbol: {
+              database_authenticatable: "Devise::Models::DatabaseAuthenticatable",
+              recoverable: "Devise::Models::Recoverable",
+              rememberable: "Devise::Models::Rememberable",
+              registerable: "Devise::Models::Registerable",
+              trackable: "Devise::Models::Trackable",
+              validatable: "Devise::Models::Validatable",
+              confirmable: "Devise::Models::Confirmable",
+              lockable: "Devise::Models::Lockable",
+              timeoutable: "Devise::Models::Timeoutable",
+              omniauthable: "Devise::Models::Omniauthable",
+              authenticatable: "Devise::Models::Authenticatable"
+            },
+            always_included: ["Devise::Models::Authenticatable"]
+          )
+        ]
+      )
+    end
+
+    Rigor::Plugin.register(Devise)
+  end
+end

data/plugins/rigor-devise/lib/rigor-devise.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Gem entry point. Required by Rigor's plugin loader when
+# `.rigor.yml` lists `rigor-devise` under `plugins:`. The loader
+# expects this `require` to side-effect a call to
+# `Rigor::Plugin.register`, which the body of
+# `lib/rigor/plugin/devise.rb` performs at load time.
+require_relative "rigor/plugin/devise"