rigortype 0.1.10 → 0.1.12

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/scope_walker.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class Rspec < Rigor::Plugin::Base
+      # Walks an RSpec spec file's AST and yields, for each
+      # describe / context block (including the outer
+      # `RSpec.describe`), a `Scope` value with the `let`
+      # and `subject` declarations recorded inside that
+      # scope.
+      #
+      # Scope hierarchy is preserved: each `Scope` carries
+      # a list of its `nested_scopes`. The analyzer uses the
+      # hierarchy to detect cross-scope shadowing.
+      #
+      # Recognised scope methods (when called without a
+      # receiver, or with `RSpec` as the receiver):
+      #
+      # - `describe` / `context` — both open a new nested
+      #   scope.
+      # - `RSpec.describe` — the outermost scope.
+      #
+      # Recognised declaration methods (inside any scope,
+      # called without a receiver):
+      #
+      # - `let(:name) { ... }` — caches the block result
+      #   per-example; recorded as a Declaration.
+      # - `let!(:name) { ... }` — same, but evaluated
+      #   eagerly via a `before` hook; same shape for our
+      #   purposes.
+      # - `subject(:name) { ... }` — special-cases name
+      #   `:subject` when called without a name.
+      module ScopeWalker
+        SCOPE_METHODS = %i[describe context].freeze
+        DECLARATION_METHODS = %i[let let! subject].freeze
+
+        # @!attribute [r] kind
+        #   `:describe`, `:context`, or `:rspec_describe` for
+        #   the root.
+        # @!attribute [r] declarations
+        #   `Array<Declaration>` declared in this scope.
+        # @!attribute [r] nested_scopes
+        #   `Array<Scope>` nested under this scope.
+        # @!attribute [r] location
+        #   `Prism::Location` of the call node that opened
+        #   this scope.
+        Scope = Struct.new(:kind, :declarations, :nested_scopes, :location, keyword_init: true)
+
+        # @!attribute [r] name
+        #   `Symbol` declared name (`:user`, `:subject`,
+        #   ...).
+        # @!attribute [r] kind
+        #   `:let`, `:let!`, or `:subject`.
+        # @!attribute [r] location
+        #   `Prism::Location` of the call node.
+        # @!attribute [r] block_node
+        #   `Prism::BlockNode` of the declaration's body.
+        Declaration = Struct.new(:name, :kind, :location, :block_node, keyword_init: true)
+
+        module_function
+
+        # Walks the parsed file and returns an array of
+        # top-level scopes (each `RSpec.describe` is a
+        # separate root). Files with no recognised scopes
+        # return an empty array.
+        def collect_scopes(root)
+          scopes = []
+          walk_top_level(root, scopes)
+          scopes
+        end
+
+        # Walks every scope in a tree (root + descendants)
+        # and yields each in turn.
+        def each_scope(scope, &)
+          yield scope
+          scope.nested_scopes.each { |child| each_scope(child, &) }
+        end
+
+        def walk_top_level(node, scopes)
+          return unless node.is_a?(Prism::Node)
+
+          if rspec_describe_call?(node)
+            scopes << build_scope(node, kind: :rspec_describe)
+          else
+            node.compact_child_nodes.each { |child| walk_top_level(child, scopes) }
+          end
+        end
+
+        # Returns true for `RSpec.describe ... do |...| ...
+        # end` calls.
+        def rspec_describe_call?(node)
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless node.name == :describe
+          return false unless node.block.is_a?(Prism::BlockNode)
+
+          receiver_name = constant_name(node.receiver)
+          %w[RSpec ::RSpec].include?(receiver_name)
+        end
+
+        # Returns true for `describe ... do ... end` /
+        # `context ... do ... end` (called without an
+        # explicit receiver — `RSpec.describe` is handled
+        # separately by `rspec_describe_call?`).
+        def nested_scope_call?(node)
+          node.is_a?(Prism::CallNode) &&
+            SCOPE_METHODS.include?(node.name) &&
+            node.block.is_a?(Prism::BlockNode) &&
+            node.receiver.nil?
+        end
+
+        def declaration_call?(node)
+          node.is_a?(Prism::CallNode) &&
+            DECLARATION_METHODS.include?(node.name) &&
+            node.receiver.nil?
+        end
+
+        # Constructs a Scope from a describe / context /
+        # RSpec.describe call node. Walks the block body
+        # for declarations + nested scopes.
+        def build_scope(call_node, kind:)
+          declarations = []
+          nested = []
+          (call_node.block.body&.compact_child_nodes || []).each do |child|
+            classify_child(child, declarations, nested)
+          end
+
+          Scope.new(
+            kind: kind,
+            declarations: declarations,
+            nested_scopes: nested,
+            location: call_node.location
+          )
+        end
+
+        def classify_child(child, declarations, nested)
+          if declaration_call?(child)
+            decl = build_declaration(child)
+            declarations << decl if decl
+          elsif nested_scope_call?(child)
+            nested << build_scope(child, kind: child.name)
+          end
+        end
+
+        def build_declaration(call_node)
+          first_arg = call_node.arguments&.arguments&.first
+          # `subject(&block)` (no name) defaults to the
+          # implicit subject; record it as `:subject`.
+          if first_arg.nil?
+            return nil unless call_node.name == :subject
+
+            return Declaration.new(
+              name: :subject,
+              kind: call_node.name,
+              location: call_node.location,
+              block_node: call_node.block
+            )
+          end
+          return nil unless first_arg.is_a?(Prism::SymbolNode)
+
+          Declaration.new(
+            name: first_arg.unescaped.to_sym,
+            kind: call_node.name,
+            location: call_node.location,
+            block_node: call_node.block
+          )
+        end
+
+        def constant_name(node)
+          case node
+          when nil then nil
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode
+            parts = []
+            current = node
+            while current.is_a?(Prism::ConstantPathNode)
+              parts.unshift(current.name.to_s)
+              current = current.parent
+            end
+            case current
+            when nil then "::#{parts.join('::')}"
+            when Prism::ConstantReadNode then "#{current.name}::#{parts.join('::')}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+require_relative "rspec/scope_walker"
+require_relative "rspec/analyzer"
+require_relative "rspec/matcher_analyzer"
+require_relative "rspec/let_scope_index"
+require_relative "rspec/let_type_resolver"
+
+module Rigor
+  module Plugin
+    # rigor-rspec — validates RSpec `let` / `subject`
+    # declarations within each describe / context scope.
+    #
+    # Tier 3A of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
+    # Deliberately scoped — the roadmap describes a much
+    # larger plugin (let-typo detection in `it` bodies,
+    # `expect(x).to receive(:method)` mock-target
+    # validation). Both are out of scope for v0.1.0; this
+    # plugin ships the two checks that have the lowest
+    # false-positive risk:
+    #
+    # 1. **Duplicate `let` / `subject` declarations** in
+    #    the same scope (`warning`). RSpec's runtime lets
+    #    the last declaration win, so the first one is
+    #    silently shadowed — almost always a copy-paste
+    #    bug.
+    # 2. **Self-referencing `let` / `subject`** — calling
+    #    the declared name *inside* its own block body
+    #    (`error`). At runtime this infinite-loops; users
+    #    typically meant to call a different method or
+    #    forgot to introduce a `super`.
+    #
+    # ## Configuration
+    #
+    # No knobs in v0.1.0. The plugin walks every analysed
+    # file looking for `RSpec.describe ... do` blocks; spec
+    # files outside the project's `paths:` are not scanned.
+    #
+    # ## Limitations (v0.1.0)
+    #
+    # - **No let-typo detection.** Detecting an `it`
+    #   block's reference to a misspelled `let` name
+    #   requires resolving every method call inside the
+    #   block against the let scope chain, the included
+    #   modules, the matchers DSL, and helper methods.
+    #   Reliable diagnostics here need a much heavier
+    #   walker — see the README's `Future direction`.
+    # - **No mock-target validation.**
+    #   `expect(x).to receive(:nme)` validating against
+    #   `x`'s methods is a separate slice; it overlaps with
+    #   the engine's general method-existence
+    #   diagnostics and needs careful coordination to avoid
+    #   double-firing.
+    # - **No shared-context resolution.** `include_context`,
+    #   `shared_context`, and `it_behaves_like` are
+    #   recognised as scope-opening calls but their
+    #   declarations are not pulled into the host scope.
+    # - **Constant validation is not done here.**
+    #   `RSpec.describe SomeClass do` does not validate
+    #   `SomeClass`; the engine's `inference.unresolved-constant`
+    #   already catches that.
+    class Rspec < Rigor::Plugin::Base
+      manifest(
+        id: "rspec",
+        version: "0.3.0",
+        description: "Validates RSpec `let` / `subject` declarations within each scope; " \
+                     "narrows expect(x).to <matcher> assertions downstream in `it` bodies; " \
+                     "binds let / subject locals to their inferred return type (Pillar 2 " \
+                     "Slice 2) — `let(:user) { User.new(...) }` / `let(:user) { create(:user) }` / " \
+                     "`subject { described_class.new(...) }`.",
+        consumes: [
+          { plugin_id: "factorybot", name: :factory_index, optional: true }
+        ]
+      )
+
+      def init(services)
+        @services = services
+        @factory_index_resolved = false
+        @factory_index = nil
+        # Per-path `LetScopeIndex` cache. The plugin's
+        # `flow_contribution_for` is called for every call
+        # node the dispatcher visits; building the index once
+        # per file is essential for performance.
+        @let_index_cache = {}
+      end
+
+      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+        # Build the let-scope index for this file while we
+        # have the parsed root in hand — `flow_contribution_for`
+        # picks it up from `@let_index_cache` keyed on path.
+        @let_index_cache[path] ||= LetScopeIndex.build(root)
+        Analyzer.diagnose(path: path, root: root).map { |diag| build_diagnostic(diag) }
+      end
+
+      # Pillar 2 Slice 1 — spec-derived flow facts from RSpec
+      # matcher assertions (six-matcher floor: `be_a`,
+      # `be_kind_of`, `be_instance_of`, `be_nil`, `eq(literal)`,
+      # `eql(literal)`; `match(/regex/)`; `not_to` / `to_not`).
+      #
+      # Pillar 2 Slice 2 (v0.3.0) — additionally binds local
+      # reads in `it` / spec bodies to their `let(:name) { ... }`
+      # block's inferred return type. Composes with Slice 1:
+      # a matcher narrowing fires after the let binding.
+      def flow_contribution_for(call_node:, scope:)
+        matcher = MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)
+        return matcher if matcher
+
+        let_binding_contribution(call_node, scope)
+      end
+
+      private
+
+      # Pillar 2 Slice 2 — when the call node is a no-receiver
+      # method call (`user`, `subject`, etc.) inside an RSpec
+      # `describe` block whose lets include a matching name,
+      # return a `FlowContribution(return_type: <inferred>)`.
+      def let_binding_contribution(call_node, scope)
+        return nil if scope.nil?
+        return nil unless candidate_call?(call_node)
+
+        index = let_scope_index_for(scope.source_path)
+        return nil if index.nil?
+
+        line = call_node.location.start_line
+        block_node = index.let_block_at(line, call_node.name)
+        return nil if block_node.nil?
+
+        describe_const = index.describe_const_at(line)
+        type = LetTypeResolver.resolve(
+          block_node,
+          describe_const: describe_const,
+          factory_index: factory_index_or_nil,
+          environment: scope.environment
+        )
+        return nil if type.nil?
+
+        Rigor::FlowContribution.new(return_type: type)
+      end
+
+      def candidate_call?(call_node)
+        call_node.is_a?(Prism::CallNode) &&
+          call_node.receiver.nil? &&
+          call_node.block.nil? &&
+          # Calls with arguments are matcher / DSL invocations,
+          # not let-bound name reads. `subject` / `user` etc.
+          # without args are the implicit-method-call shape RSpec
+          # uses to expose let / subject in `it` bodies.
+          (call_node.arguments.nil? || call_node.arguments.arguments.empty?)
+      end
+
+      def let_scope_index_for(path)
+        return nil if path.nil?
+        return @let_index_cache[path] if @let_index_cache.key?(path)
+
+        @let_index_cache[path] = build_let_scope_index(path)
+      end
+
+      def build_let_scope_index(path)
+        source = io_boundary.read_file(path)
+        parse_result = Prism.parse(source)
+        return nil unless parse_result.errors.empty?
+
+        LetScopeIndex.build(parse_result.value)
+      rescue Rigor::Plugin::AccessDeniedError, Errno::ENOENT
+        nil
+      end
+
+      def factory_index_or_nil
+        return @factory_index if @factory_index_resolved
+
+        @factory_index = @services&.fact_store&.read(plugin_id: "factorybot", name: :factory_index)
+        @factory_index_resolved = true
+        @factory_index
+      end
+
+      def build_diagnostic(diag)
+        Rigor::Analysis::Diagnostic.new(
+          path: diag.path, line: diag.line, column: diag.column,
+          message: diag.message, severity: diag.severity, rule: diag.rule
+        )
+      end
+    end
+
+    Rigor::Plugin.register(Rspec)
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rigor/plugin/rspec"

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "http_status_codes"
+
+module Rigor
+  module Plugin
+    class RspecRails < Rigor::Plugin::Base
+      # Validates `expect(response).to have_http_status(arg)` /
+      # the negated `.not_to have_http_status(arg)` and the
+      # bare matcher form `should have_http_status(arg)`.
+      #
+      # Recognised argument shapes:
+      #
+      # - **IntegerNode**: must be in `100..599`. Numbers outside
+      #   that range fire `have_http_status.out-of-range`.
+      # - **SymbolNode**: must be one of the known
+      #   `Rack::Utils::SYMBOL_TO_STATUS_CODE` keys OR a Rails
+      #   status-group alias (`:success` / `:successful` /
+      #   `:missing` / `:redirect` / `:error` / `:client_error` /
+      #   `:server_error` / `:informational`). Unknown symbols
+      #   fire `have_http_status.unknown-symbol` (typo-flavoured).
+      # - **StringNode**: passed through silently (a literal
+      #   `"200"` is accepted by Rails at runtime; we don't
+      #   second-guess the user's intent for the String form).
+      # - **Anything else** (variable, method call, computed
+      #   expression): skipped — the plugin can't statically
+      #   prove the runtime value.
+      #
+      # Walks every `Prism::CallNode` looking for matcher
+      # invocations rather than only the `expect(...).to ...`
+      # chain because `have_http_status` is also used as a
+      # plain matcher inside Rails' `assert_response` shim and
+      # in shared-context bodies; the diagnostic is the same
+      # regardless of the surrounding chain.
+      module HaveHttpStatusAnalyzer
+        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+
+        MATCHER_NAME = :have_http_status
+
+        module_function
+
+        # @param path [String]
+        # @param root [Prism::Node]
+        # @return [Array<Diagnostic>]
+        def diagnose(path:, root:)
+          diagnostics = []
+          walk(root) do |call_node|
+            diagnostic = diagnostic_for(call_node, path)
+            diagnostics << diagnostic if diagnostic
+          end
+          diagnostics
+        end
+
+        def walk(node, &)
+          return unless node.is_a?(Prism::Node)
+
+          yield node if call_to_matcher?(node)
+          node.compact_child_nodes.each { |child| walk(child, &) }
+        end
+
+        # `have_http_status` is a matcher — called either with
+        # no receiver (`have_http_status(200)` inside `.to(...)`)
+        # or with a receiver chain we don't care about here.
+        # Either way we want the call node whose name is
+        # `have_http_status` and that carries exactly one
+        # positional argument.
+        def call_to_matcher?(node)
+          node.is_a?(Prism::CallNode) &&
+            node.name == MATCHER_NAME &&
+            single_positional?(node)
+        end
+
+        def single_positional?(call_node)
+          args = call_node.arguments&.arguments || []
+          args.size == 1
+        end
+
+        def diagnostic_for(call_node, path)
+          arg = call_node.arguments.arguments.first
+          case arg
+          when Prism::IntegerNode then integer_diagnostic(call_node, path, arg)
+          when Prism::SymbolNode then symbol_diagnostic(call_node, path, arg)
+          end
+        end
+
+        def integer_diagnostic(call_node, path, integer_node)
+          value = integer_node.value
+          return nil if HttpStatusCodes::VALID_NUMERIC_RANGE.cover?(value)
+
+          build_diagnostic(
+            call_node, path,
+            rule: "have_http_status.out-of-range",
+            message: "have_http_status(#{value}) is outside the valid HTTP status " \
+                     "range #{HttpStatusCodes::VALID_NUMERIC_RANGE}"
+          )
+        end
+
+        def symbol_diagnostic(call_node, path, symbol_node)
+          sym = symbol_node.unescaped.to_sym
+          return nil if HttpStatusCodes::KNOWN_SYMBOLS.include?(sym)
+
+          build_diagnostic(
+            call_node, path,
+            rule: "have_http_status.unknown-symbol",
+            message: "have_http_status(:#{sym}) is not a recognised HTTP status symbol " \
+                     "(see Rack::Utils::SYMBOL_TO_STATUS_CODE) or Rails status-group " \
+                     "alias (:success / :successful / :missing / :redirect / :error / " \
+                     ":client_error / :server_error / :informational)"
+          )
+        end
+
+        def build_diagnostic(call_node, path, rule:, message:)
+          location = call_node.message_loc || call_node.location
+          Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            severity: :warning,
+            rule: rule,
+            message: message
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class RspecRails < Rigor::Plugin::Base
+      # Curated set of HTTP-status symbols `have_http_status`
+      # accepts. Derived from `Rack::Utils::SYMBOL_TO_STATUS_CODE`
+      # (Rack 3.x snapshot) plus Rails' status-group aliases
+      # accepted by `ActionDispatch::TestResponse`.
+      #
+      # Vendored as a frozen Set so the plugin has no
+      # `rack` / `actionpack` runtime dependency — checking
+      # against a static catalogue is intentional: a future
+      # Rack release that adds a new alias would require
+      # bumping this constant, but the false-positive risk is
+      # bounded (the diagnostic just suggests a typo when in
+      # fact the symbol is newly-added).
+      module HttpStatusCodes
+        SYMBOL_TO_STATUS_CODE = {
+          # 1xx Informational
+          continue: 100, switching_protocols: 101, processing: 102, early_hints: 103,
+          # 2xx Success
+          ok: 200, created: 201, accepted: 202, non_authoritative_information: 203,
+          no_content: 204, reset_content: 205, partial_content: 206, multi_status: 207,
+          already_reported: 208, im_used: 226,
+          # 3xx Redirection
+          multiple_choices: 300, moved_permanently: 301, found: 302, see_other: 303,
+          not_modified: 304, use_proxy: 305, temporary_redirect: 307,
+          permanent_redirect: 308,
+          # 4xx Client Error
+          bad_request: 400, unauthorized: 401, payment_required: 402, forbidden: 403,
+          not_found: 404, method_not_allowed: 405, not_acceptable: 406,
+          proxy_authentication_required: 407, request_timeout: 408, conflict: 409,
+          gone: 410, length_required: 411, precondition_failed: 412,
+          payload_too_large: 413, uri_too_long: 414, unsupported_media_type: 415,
+          range_not_satisfiable: 416, expectation_failed: 417, misdirected_request: 421,
+          unprocessable_entity: 422, unprocessable_content: 422, locked: 423,
+          failed_dependency: 424, too_early: 425, upgrade_required: 426,
+          precondition_required: 428, too_many_requests: 429,
+          request_header_fields_too_large: 431, unavailable_for_legal_reasons: 451,
+          # 5xx Server Error
+          internal_server_error: 500, not_implemented: 501, bad_gateway: 502,
+          service_unavailable: 503, gateway_timeout: 504, http_version_not_supported: 505,
+          variant_also_negotiates: 506, insufficient_storage: 507, loop_detected: 508,
+          not_extended: 510, network_authentication_required: 511,
+          # Rails status-group aliases (see
+          # ActionDispatch::TestResponse RESPONSE_PREDICATES)
+          informational: :informational_group, success: :success_group,
+          successful: :success_group, redirect: :redirect_group,
+          client_error: :client_error_group, missing: :client_error_group,
+          server_error: :server_error_group, error: :server_error_group
+        }.freeze
+
+        KNOWN_SYMBOLS = SYMBOL_TO_STATUS_CODE.keys.to_set.freeze
+
+        VALID_NUMERIC_RANGE = (100..599)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+require_relative "rspec_rails/have_http_status_analyzer"
+
+module Rigor
+  module Plugin
+    # 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`,
+    #   `: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`.
+    #
+    # ## 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`
+    #   (`: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.
+    # - `be_routable` — needs routes table.
+    # - `match_response_schema(...)` (rswag / OpenAPI) — out
+    #   of scope, separate plugin.
+    class RspecRails < Rigor::Plugin::Base
+      manifest(
+        id: "rspec-rails",
+        version: "0.1.0",
+        description: "Validates rspec-rails behavioral matchers (have_http_status floor)."
+      )
+
+      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+        HaveHttpStatusAnalyzer.diagnose(path: path, root: root).map { |diag| build_diagnostic(diag) }
+      end
+
+      private
+
+      def build_diagnostic(diag)
+        Rigor::Analysis::Diagnostic.new(
+          path: diag.path, line: diag.line, column: diag.column,
+          message: diag.message, severity: diag.severity, rule: diag.rule
+        )
+      end
+    end
+
+    Rigor::Plugin.register(RspecRails)
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rigor/plugin/rspec_rails"