rigortype 0.1.10 → 0.1.11

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

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "prism"
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # Example plugin: validates state-machine references.
+    # Demonstrates the **two-pass DSL analysis** pattern many
+    # plugins reuse:
+    #
+    #   1. **Collect pass.** Walk the file once to gather every
+    #      state name declared inside a `state_machine do ... end`
+    #      block (`state :draft`, `state :submitted`, ...).
+    #   2. **Validate pass.** Walk the file again, validating each
+    #      `transition_to(:sym)` and `event :sym` reference against
+    #      the collected state set. Levenshtein distance ≤ 3 drives
+    #      the did-you-mean suggestions.
+    #
+    # Useful for `aasm` / `statesman` / hand-rolled DSLs and any
+    # framework where declarations and uses live in the same
+    # file. The same skeleton lifts to GraphQL types,
+    # ActiveModel validations, route declarations — anywhere a
+    # declarative DSL produces a closed namespace and the rest
+    # of the file references that namespace by literal symbol.
+    #
+    # ## Configuration
+    #
+    # Defaults match the `Statesman::Machine` API; override via
+    # `.rigor.yml` if your DSL uses different names:
+    #
+    #     plugins:
+    #       - gem: rigor-statesman
+    #         config:
+    #           dsl_method: state_machine    # the do-block opener
+    #           state_method: state          # state declaration inside the block
+    #           transition_method: transition_to  # call-site under check
+    #
+    # ## Diagnostics
+    #
+    # | Event                                    | Severity | Rule              |
+    # | ---                                      | ---      | ---               |
+    # | `transition_to(:known_state)`            | `:info`  | `known-state`     |
+    # | `transition_to(:typo)` (close match)     | `:error` | `unknown-state` (with did-you-mean) |
+    # | `transition_to(:typo)` (no close match)  | `:error` | `unknown-state`   |
+    # | file declares no state machine           | silent   | —                 |
+    class Statesman < Rigor::Plugin::Base
+      manifest(
+        id: "statesman",
+        version: "0.1.0",
+        description: "Validates state-machine transition references against declared states.",
+        config_schema: {
+          "dsl_method" => :string,
+          "state_method" => :string,
+          "transition_method" => :string
+        }
+      )
+
+      DEFAULT_DSL_METHOD = "state_machine"
+      DEFAULT_STATE_METHOD = "state"
+      DEFAULT_TRANSITION_METHOD = "transition_to"
+      DID_YOU_MEAN_DISTANCE = 3
+
+      def init(_services)
+        @dsl_method = config.fetch("dsl_method", DEFAULT_DSL_METHOD).to_sym
+        @state_method = config.fetch("state_method", DEFAULT_STATE_METHOD).to_sym
+        @transition_method = config.fetch("transition_method", DEFAULT_TRANSITION_METHOD).to_sym
+      end
+
+      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+        states = collect_states(root)
+        return [] if states.empty?
+
+        validate_transitions(path, root, states)
+      end
+
+      private
+
+      # Pass 1 — every `state :foo` declaration inside a
+      # `<dsl_method> do ... end` block on the file. Returns a
+      # frozen Set of state name Symbols.
+      def collect_states(root)
+        states = Set.new
+        walk(root) do |node|
+          next unless dsl_call?(node)
+
+          walk(node.block) do |inner|
+            next unless state_declaration?(inner)
+
+            sym = literal_symbol_arg(inner, 0)
+            states << sym if sym
+          end
+        end
+        states.freeze
+      end
+
+      # Pass 2 — every `<transition_method>(:sym)` call.
+      def validate_transitions(path, root, states)
+        diagnostics = []
+        walk(root) do |node|
+          next unless transition_call?(node)
+
+          sym = literal_symbol_arg(node, 0)
+          next if sym.nil? # not a literal — defer to runtime
+
+          diagnostics << build_diagnostic(path, node, sym, states)
+        end
+        diagnostics
+      end
+
+      def build_diagnostic(path, node, sym, states)
+        if states.include?(sym)
+          diagnostic(
+            path, node,
+            severity: :info,
+            rule: "known-state",
+            message: "#{@transition_method}(:#{sym}) — declared state"
+          )
+        else
+          hint = did_you_mean(sym, states)
+          message = "unknown state :#{sym}"
+          message += " (did you mean :#{hint}?)" if hint
+          diagnostic(path, node, severity: :error, rule: "unknown-state", message: message)
+        end
+      end
+
+      def dsl_call?(node)
+        node.is_a?(Prism::CallNode) &&
+          node.name == @dsl_method &&
+          node.block
+      end
+
+      def state_declaration?(node)
+        node.is_a?(Prism::CallNode) &&
+          node.name == @state_method &&
+          !node.arguments.nil?
+      end
+
+      def transition_call?(node)
+        node.is_a?(Prism::CallNode) &&
+          node.name == @transition_method &&
+          !node.arguments.nil?
+      end
+
+      def literal_symbol_arg(call, index)
+        node = call.arguments.arguments[index]
+        return nil unless node.is_a?(Prism::SymbolNode)
+
+        node.unescaped.to_sym
+      end
+
+      def walk(node, &)
+        return if node.nil?
+
+        yield node
+        node.compact_child_nodes.each { |child| walk(child, &) }
+      end
+
+      def did_you_mean(name, states)
+        target = name.to_s
+        best = nil
+        best_distance = DID_YOU_MEAN_DISTANCE + 1
+        states.each do |state|
+          distance = levenshtein(target, state.to_s)
+          if distance < best_distance
+            best = state
+            best_distance = distance
+          end
+        end
+        best
+      end
+
+      def levenshtein(a, b) # rubocop:disable Naming/MethodParameterName
+        return b.length if a.empty?
+        return a.length if b.empty?
+
+        rows = Array.new(a.length + 1) { |_i| Array.new(b.length + 1, 0) }
+        (0..a.length).each { |i| rows[i][0] = i }
+        (0..b.length).each { |j| rows[0][j] = j }
+
+        (1..a.length).each do |i|
+          (1..b.length).each do |j|
+            cost = a[i - 1] == b[j - 1] ? 0 : 1
+            rows[i][j] = [
+              rows[i - 1][j] + 1,
+              rows[i][j - 1] + 1,
+              rows[i - 1][j - 1] + cost
+            ].min
+          end
+        end
+        rows[a.length][b.length]
+      end
+
+      def diagnostic(path, node, severity:, rule:, message:)
+        location = node.location
+        Rigor::Analysis::Diagnostic.new(
+          path: path,
+          line: location.start_line,
+          column: location.start_column + 1,
+          message: message,
+          severity: severity,
+          rule: rule
+        )
+      end
+    end
+
+    Rigor::Plugin.register(Statesman)
+  end
+end

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

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

data/plugins/rigor-typescript-utility-types/lib/rigor/plugin/typescript_utility_types.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # Example plugin: ships the TypeScript-canonical utility-type
+    # aliases (`Pick<T, K>`, `Omit<T, K>`, `Partial<T>`,
+    # `Required<T>`, `Readonly<T>`) as opt-in vocabulary that
+    # resolves to the Rigor-canonical shape-projection type
+    # functions introduced in ADR-13.
+    #
+    # Background. `docs/type-specification/imported-built-in-types.md`
+    # § "Deferred or rejected imports" deliberately rejects
+    # TypeScript-canonical names from the Rigor core surface: the
+    # core stays RBS-canonical per ADR-0 / ADR-1, and the shape
+    # semantics live in core under `pick_of[T, K]` /
+    # `omit_of[T, K]` / `partial_of[T]` / `required_of[T]` /
+    # `readonly_of[T]` (added in ADR-13 slice 4). This plugin
+    # ships the TS spellings as an opt-in translation layer for
+    # users migrating from TypeScript / Sorbet / Flow-style RBI.
+    #
+    # Off by default — users add the gem to their `.rigor.yml`
+    # plugins list to enable.
+    #
+    # @example .rigor.yml
+    #   plugins:
+    #     - gem: rigor-typescript-utility-types
+    #
+    # Once loaded, an RBS::Extended payload such as
+    # `%a{rigor:v1:return: Pick[Foo, :a | :b]}` resolves through
+    # the chain: the parser builds a `Generic("Pick", …)` AST,
+    # the registry / built-in parametric builders decline, the
+    # chain consults `Resolvers::Pick`, which recursively
+    # resolves the two arguments to Rigor types and calls
+    # `Type::Combinator.pick_of` on them.
+    #
+    # ## Translation table
+    #
+    # | TypeScript spelling | Rigor core call                          |
+    # | --- | --- |
+    # | `Pick<T, K>`     | `Type::Combinator.pick_of(T, K)`     |
+    # | `Omit<T, K>`     | `Type::Combinator.omit_of(T, K)`     |
+    # | `Partial<T>`     | `Type::Combinator.partial_of(T)`     |
+    # | `Required<T>`    | `Type::Combinator.required_of(T)`    |
+    # | `Readonly<T>`    | `Type::Combinator.readonly_of(T)`    |
+    #
+    # ## Deferred TypeScript utility names
+    #
+    # `Parameters<F>` / `ReturnType<F>` / `InstanceType<C>` /
+    # `Awaited<P>` / `Uppercase<S>` / `Lowercase<S>` /
+    # `Capitalize<S>` / `Uncapitalize<S>` / `ThisParameterType<F>`
+    # / `OmitThisParameter<F>` / `ConstructorParameters<C>` /
+    # `NoInfer<T>` are NOT mapped today. The plugin returns `nil`
+    # from `#resolve` for those heads, leaving the parser's
+    # default Nominal-fallback to produce `Nominal[ReturnType, …]`
+    # etc. Function-type projection operators (`params_of[F]` /
+    # `return_of[F]`) and class projections (`instance_type[C]`)
+    # would unlock these — they remain deferred in core.
+    class TypescriptUtilityTypes < Rigor::Plugin::Base
+      module Resolvers
+        # Common helper: extract a single-arg utility-type Generic
+        # whose head matches `name`. Returns the resolved
+        # argument's `Rigor::Type` or `nil` (so the chain falls
+        # through).
+        module SingleArg
+          def self.resolve(node, scope, name)
+            return nil unless node.is_a?(Rigor::TypeNode::Generic)
+            return nil unless node.head == name
+            return nil unless node.args.size == 1
+
+            scope.resolver.resolve(node.args[0], scope)
+          end
+        end
+
+        # Common helper for two-arg utility types.
+        module TwoArg
+          def self.resolve(node, scope, name)
+            return nil unless node.is_a?(Rigor::TypeNode::Generic)
+            return nil unless node.head == name
+            return nil unless node.args.size == 2
+
+            [scope.resolver.resolve(node.args[0], scope),
+             scope.resolver.resolve(node.args[1], scope)]
+          end
+        end
+
+        # `Pick<T, K>` → `pick_of[T, K]`.
+        class Pick < Rigor::Plugin::TypeNodeResolver
+          def resolve(node, scope)
+            resolved = TwoArg.resolve(node, scope, "Pick")
+            return nil if resolved.nil?
+
+            t_type, k_type = resolved
+            return nil if t_type.nil? || k_type.nil?
+
+            Rigor::Type::Combinator.pick_of(t_type, k_type)
+          end
+        end
+
+        # `Omit<T, K>` → `omit_of[T, K]`.
+        class Omit < Rigor::Plugin::TypeNodeResolver
+          def resolve(node, scope)
+            resolved = TwoArg.resolve(node, scope, "Omit")
+            return nil if resolved.nil?
+
+            t_type, k_type = resolved
+            return nil if t_type.nil? || k_type.nil?
+
+            Rigor::Type::Combinator.omit_of(t_type, k_type)
+          end
+        end
+
+        # `Partial<T>` → `partial_of[T]`.
+        class Partial < Rigor::Plugin::TypeNodeResolver
+          def resolve(node, scope)
+            t_type = SingleArg.resolve(node, scope, "Partial")
+            return nil if t_type.nil?
+
+            Rigor::Type::Combinator.partial_of(t_type)
+          end
+        end
+
+        # `Required<T>` → `required_of[T]`.
+        class Required < Rigor::Plugin::TypeNodeResolver
+          def resolve(node, scope)
+            t_type = SingleArg.resolve(node, scope, "Required")
+            return nil if t_type.nil?
+
+            Rigor::Type::Combinator.required_of(t_type)
+          end
+        end
+
+        # `Readonly<T>` → `readonly_of[T]`.
+        class Readonly < Rigor::Plugin::TypeNodeResolver
+          def resolve(node, scope)
+            t_type = SingleArg.resolve(node, scope, "Readonly")
+            return nil if t_type.nil?
+
+            Rigor::Type::Combinator.readonly_of(t_type)
+          end
+        end
+      end
+
+      manifest(
+        id: "typescript-utility-types",
+        version: "0.1.0",
+        description: "Maps TypeScript-canonical utility-type aliases " \
+                     "(Pick, Omit, Partial, Required, Readonly) onto the " \
+                     "Rigor-canonical shape-projection type functions.",
+        type_node_resolvers: [
+          Resolvers::Pick.new,
+          Resolvers::Omit.new,
+          Resolvers::Partial.new,
+          Resolvers::Required.new,
+          Resolvers::Readonly.new
+        ]
+      )
+    end
+
+    register(TypescriptUtilityTypes)
+  end
+end

data/plugins/rigor-typescript-utility-types/lib/rigor-typescript-utility-types.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Rigor contributors
@@ -476,6 +476,125 @@ files:
 - lib/rigor/type_node/symbol_literal.rb
 - lib/rigor/type_node/union.rb
 - lib/rigor/version.rb
+- plugins/rigor-actioncable/lib/rigor-actioncable.rb
+- plugins/rigor-actioncable/lib/rigor/plugin/actioncable.rb
+- plugins/rigor-actioncable/lib/rigor/plugin/actioncable/analyzer.rb
+- plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_discoverer.rb
+- plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_index.rb
+- plugins/rigor-actionmailer/lib/rigor-actionmailer.rb
+- plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer.rb
+- plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/analyzer.rb
+- plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_discoverer.rb
+- plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_index.rb
+- plugins/rigor-actionpack/lib/rigor-actionpack.rb
+- plugins/rigor-actionpack/lib/rigor/plugin/actionpack.rb
+- plugins/rigor-actionpack/lib/rigor/plugin/actionpack/analyzer.rb
+- plugins/rigor-actionpack/lib/rigor/plugin/actionpack/controller_discoverer.rb
+- plugins/rigor-actionpack/lib/rigor/plugin/actionpack/controller_index.rb
+- plugins/rigor-activejob/lib/rigor-activejob.rb
+- plugins/rigor-activejob/lib/rigor/plugin/activejob.rb
+- plugins/rigor-activejob/lib/rigor/plugin/activejob/analyzer.rb
+- plugins/rigor-activejob/lib/rigor/plugin/activejob/job_discoverer.rb
+- plugins/rigor-activejob/lib/rigor/plugin/activejob/job_index.rb
+- plugins/rigor-activerecord/lib/rigor-activerecord.rb
+- plugins/rigor-activerecord/lib/rigor/plugin/activerecord.rb
+- plugins/rigor-activerecord/lib/rigor/plugin/activerecord/analyzer.rb
+- plugins/rigor-activerecord/lib/rigor/plugin/activerecord/inflector.rb
+- plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_discoverer.rb
+- plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_index.rb
+- plugins/rigor-activerecord/lib/rigor/plugin/activerecord/schema_parser.rb
+- plugins/rigor-activerecord/lib/rigor/plugin/activerecord/schema_table.rb
+- plugins/rigor-activerecord/sig/active_record/relation.rbs
+- plugins/rigor-activestorage/lib/rigor-activestorage.rb
+- plugins/rigor-activestorage/lib/rigor/plugin/activestorage.rb
+- plugins/rigor-activestorage/lib/rigor/plugin/activestorage/analyzer.rb
+- plugins/rigor-activestorage/lib/rigor/plugin/activestorage/attachment_discoverer.rb
+- plugins/rigor-activestorage/lib/rigor/plugin/activestorage/attachment_index.rb
+- plugins/rigor-activesupport-core-ext/lib/rigor-activesupport-core-ext.rb
+- plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext.rb
+- plugins/rigor-activesupport-core-ext/sig/active_support/core_ext.rbs
+- plugins/rigor-devise/lib/rigor-devise.rb
+- plugins/rigor-devise/lib/rigor/plugin/devise.rb
+- plugins/rigor-dry-schema/lib/rigor-dry-schema.rb
+- plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema.rb
+- plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema/schema_scanner.rb
+- plugins/rigor-dry-struct/lib/rigor-dry-struct.rb
+- plugins/rigor-dry-struct/lib/rigor/plugin/dry_struct.rb
+- plugins/rigor-dry-types/lib/rigor-dry-types.rb
+- plugins/rigor-dry-types/lib/rigor/plugin/dry_types.rb
+- plugins/rigor-dry-types/lib/rigor/plugin/dry_types/alias_scanner.rb
+- plugins/rigor-dry-validation/lib/rigor-dry-validation.rb
+- plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation.rb
+- plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation/contract_scanner.rb
+- plugins/rigor-dry-validation/sig/dry_validation.rbs
+- plugins/rigor-factorybot/lib/rigor-factorybot.rb
+- plugins/rigor-factorybot/lib/rigor/plugin/factorybot.rb
+- plugins/rigor-factorybot/lib/rigor/plugin/factorybot/analyzer.rb
+- plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_discoverer.rb
+- plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_index.rb
+- plugins/rigor-graphql/lib/rigor-graphql.rb
+- plugins/rigor-graphql/lib/rigor/plugin/graphql.rb
+- plugins/rigor-graphql/lib/rigor/plugin/graphql/type_scanner.rb
+- plugins/rigor-hanami/lib/rigor-hanami.rb
+- plugins/rigor-hanami/lib/rigor/plugin/hanami.rb
+- plugins/rigor-hanami/lib/rigor/plugin/hanami/action_checker.rb
+- plugins/rigor-hanami/sig/hanami_action.rbs
+- plugins/rigor-minitest/lib/rigor-minitest.rb
+- plugins/rigor-minitest/lib/rigor/plugin/minitest.rb
+- plugins/rigor-minitest/lib/rigor/plugin/minitest/assertion_analyzer.rb
+- plugins/rigor-pundit/lib/rigor-pundit.rb
+- plugins/rigor-pundit/lib/rigor/plugin/pundit.rb
+- plugins/rigor-pundit/lib/rigor/plugin/pundit/analyzer.rb
+- plugins/rigor-pundit/lib/rigor/plugin/pundit/policy_discoverer.rb
+- plugins/rigor-pundit/lib/rigor/plugin/pundit/policy_index.rb
+- plugins/rigor-rails-i18n/lib/rigor-rails-i18n.rb
+- plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n.rb
+- plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/analyzer.rb
+- plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_index.rb
+- plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_loader.rb
+- plugins/rigor-rails-routes/lib/rigor-rails-routes.rb
+- plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes.rb
+- plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/analyzer.rb
+- plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/helper_table.rb
+- plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/routes_parser.rb
+- plugins/rigor-rails/lib/rigor-rails.rb
+- plugins/rigor-rbs-inline/lib/rigor-rbs-inline.rb
+- plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb
+- plugins/rigor-rspec-rails/lib/rigor-rspec-rails.rb
+- plugins/rigor-rspec-rails/lib/rigor/plugin/rspec_rails.rb
+- plugins/rigor-rspec-rails/lib/rigor/plugin/rspec_rails/have_http_status_analyzer.rb
+- plugins/rigor-rspec-rails/lib/rigor/plugin/rspec_rails/http_status_codes.rb
+- plugins/rigor-rspec/lib/rigor-rspec.rb
+- plugins/rigor-rspec/lib/rigor/plugin/rspec.rb
+- plugins/rigor-rspec/lib/rigor/plugin/rspec/analyzer.rb
+- plugins/rigor-rspec/lib/rigor/plugin/rspec/let_scope_index.rb
+- plugins/rigor-rspec/lib/rigor/plugin/rspec/let_type_resolver.rb
+- plugins/rigor-rspec/lib/rigor/plugin/rspec/matcher_analyzer.rb
+- plugins/rigor-rspec/lib/rigor/plugin/rspec/scope_walker.rb
+- plugins/rigor-shoulda-matchers/lib/rigor-shoulda-matchers.rb
+- plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers.rb
+- plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers/analyzer.rb
+- plugins/rigor-sidekiq/lib/rigor-sidekiq.rb
+- plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq.rb
+- plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/analyzer.rb
+- plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/worker_discoverer.rb
+- plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/worker_index.rb
+- plugins/rigor-sinatra/lib/rigor-sinatra.rb
+- plugins/rigor-sinatra/lib/rigor/plugin/sinatra.rb
+- plugins/rigor-sorbet/lib/rigor-sorbet.rb
+- plugins/rigor-sorbet/lib/rigor/plugin/sorbet.rb
+- plugins/rigor-sorbet/lib/rigor/plugin/sorbet/absurd_recognizer.rb
+- plugins/rigor-sorbet/lib/rigor/plugin/sorbet/assertion_recognizer.rb
+- plugins/rigor-sorbet/lib/rigor/plugin/sorbet/catalog.rb
+- plugins/rigor-sorbet/lib/rigor/plugin/sorbet/catalog_walker.rb
+- plugins/rigor-sorbet/lib/rigor/plugin/sorbet/method_signature.rb
+- plugins/rigor-sorbet/lib/rigor/plugin/sorbet/sig_parser.rb
+- plugins/rigor-sorbet/lib/rigor/plugin/sorbet/sigil_detector.rb
+- plugins/rigor-sorbet/lib/rigor/plugin/sorbet/type_translator.rb
+- plugins/rigor-statesman/lib/rigor-statesman.rb
+- plugins/rigor-statesman/lib/rigor/plugin/statesman.rb
+- plugins/rigor-typescript-utility-types/lib/rigor-typescript-utility-types.rb
+- plugins/rigor-typescript-utility-types/lib/rigor/plugin/typescript_utility_types.rb
 - sig/rigor.rbs
 - sig/rigor/analysis/baseline.rbs
 - sig/rigor/analysis/check_rules/always_truthy_condition_collector.rbs
@@ -524,6 +643,35 @@ metadata:
 rdoc_options: []
 require_paths:
 - lib
+- plugins/rigor-actioncable/lib
+- plugins/rigor-actionmailer/lib
+- plugins/rigor-actionpack/lib
+- plugins/rigor-activejob/lib
+- plugins/rigor-activerecord/lib
+- plugins/rigor-activestorage/lib
+- plugins/rigor-activesupport-core-ext/lib
+- plugins/rigor-devise/lib
+- plugins/rigor-dry-schema/lib
+- plugins/rigor-dry-struct/lib
+- plugins/rigor-dry-types/lib
+- plugins/rigor-dry-validation/lib
+- plugins/rigor-factorybot/lib
+- plugins/rigor-graphql/lib
+- plugins/rigor-hanami/lib
+- plugins/rigor-minitest/lib
+- plugins/rigor-pundit/lib
+- plugins/rigor-rails/lib
+- plugins/rigor-rails-i18n/lib
+- plugins/rigor-rails-routes/lib
+- plugins/rigor-rbs-inline/lib
+- plugins/rigor-rspec/lib
+- plugins/rigor-rspec-rails/lib
+- plugins/rigor-shoulda-matchers/lib
+- plugins/rigor-sidekiq/lib
+- plugins/rigor-sinatra/lib
+- plugins/rigor-sorbet/lib
+- plugins/rigor-statesman/lib
+- plugins/rigor-typescript-utility-types/lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="