rigortype 0.2.8 → 0.2.9

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

@@ -62,6 +62,9 @@ class Object
   # `acts_like?(:string)` / `acts_like?(:date)` / `acts_like?(:time)`
   # is ActiveSupport's "duck-typing helper" predicate.
   def acts_like?: (Symbol | String) -> bool
+
+  # `core_ext/object/inclusion` — `x.in?([a, b])` / `x.in?(1..10)`.
+  def in?: (untyped) -> bool
 end
 
 # `nil.blank?` / `nil.present?` / `nil.try` are the most frequent
@@ -99,6 +102,9 @@ class String
   def demodulize: () -> String
   def deconstantize: () -> String
   def titleize: () -> String
+  def titlecase: () -> String
+  def dasherize: () -> String
+  def upcase_first: () -> 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
@@ -112,6 +118,9 @@ class 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
+  # `remove` / `remove!` delete every occurrence of the given patterns.
+  def remove: (*Regexp | String patterns) -> String
+  def remove!: (*Regexp | String patterns) -> String
 
   # `core_ext/string/output_safety` — `html_safe` returns an
   # `ActiveSupport::SafeBuffer` (a String subclass). The closest
@@ -274,6 +283,9 @@ class Time
   def noon: () -> Time
   def utc?: () -> bool
   def acts_like_time?: () -> true
+  # `advance(days: 1, months: -2)` and `all_day` (a `beginning_of_day..end_of_day` Range).
+  def advance: (untyped options) -> Time
+  def all_day: () -> Range[Time]
 end
 
 # ---------------------------------------------------------------
@@ -314,6 +326,11 @@ class Date
   def at_beginning_of_day: () -> Time
   def end_of_day: () -> Time
   def at_end_of_day: () -> Time
+  # `advance(days: 1)`, `all_day` (a Time Range), and `to_time(form)` — the
+  # `:local` / `:utc` form arg core RBS' `Date#to_time` (arity 0) omits.
+  def advance: (untyped options) -> Date
+  def all_day: () -> Range[Time]
+  def to_time: (?Symbol form) -> Time
 end
 
 # ---------------------------------------------------------------
@@ -476,3 +493,18 @@ end
 class String
   def exclude?: (String) -> bool
 end
+
+# ---------------------------------------------------------------
+# ERB::Util — ActionView extends it with `html_escape_once`
+# ---------------------------------------------------------------
+
+# `ERB` is a CLASS in Ruby / RBS (not a module), so reopen it as a class —
+# a `module ERB` wrapper collides with upstream `class ERB` once the `erb`
+# stdlib is in scope. `ERB::Util` itself is a module.
+class ERB
+  module Util
+    # `ERB::Util.html_escape_once(s)` escapes HTML without double-escaping
+    # an already-escaped entity. ActionView adds it on top of stdlib ERB.
+    def self.html_escape_once: (untyped) -> String
+  end
+end

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/grape_api_discoverer.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class RailsRoutes < Rigor::Plugin::Base
+      # Recognises the helper *namespaces* the `grape-path-helpers` gem generates, so a call to one of them
+      # does not false-fire `unknown-helper`.
+      #
+      # The gem names each helper after its route's path segments, joined with `_`
+      # (`DecoratedRoute#path_helper_name`): `/api/:version/groups/:id/badges` under `version 'v4'` becomes
+      # `api_v4_groups_badges_path`. It walks `Grape::API::Instance.routes` — the *runtime* route table — and
+      # real grape sources build that table with metaprogramming (GitLab's `%w[group project].each { |t|
+      # resource t.pluralize … }`). A static parser cannot enumerate those names, and deriving only the
+      # easy ones would be worse than deriving none: every route it missed would keep firing on working
+      # code.
+      #
+      # What IS static is the leading segments. `prefix :api` contributes the first; `version 'v4'`
+      # contributes the second when the strategy is `:path` (Grape's default — `using: :header` / `:param`
+      # keeps the version out of the URL, and so out of the helper name). Both are literal arguments in the
+      # body of a class whose superclass chain reaches `Grape::API`. Everything after them is opaque.
+      #
+      # So the namespace `api_v4_…_path` is treated as open — a name the project's routes may define but
+      # Rigor cannot enumerate, so proving it undefined is unsound (the ADR-26 `open_receivers` reasoning,
+      # already applied in this plugin to Devise's runtime-provider OmniAuth family). Teeth survive where the
+      # gem's own contract keeps them sound: it defines no `_url` helper
+      # (`NamedRouteMatcher#method_missing` returns `super` unless the name ends `_path`), so
+      # `api_v4_anything_url` still fires, as does any name outside a declared prefix.
+      #
+      # Design note: `docs/notes/20260710-grape-path-helper-namespace.md`.
+      module GrapeApiDiscoverer
+        # A class is a grape API when its superclass chain reaches one of these. `Grape::API::Instance` is
+        # what a mounted `Grape::API` subclass actually becomes, and real code inherits from it directly
+        # (GitLab's `API::Base < Grape::API::Instance`).
+        GRAPE_BASE_NAMES = ["Grape::API", "Grape::API::Instance"].freeze
+
+        # `version 'v4', using: :path` puts the version in the URL. `:header` / `:param` do not, so those
+        # versions contribute no helper-name segment. Grape's default strategy is `:path`.
+        PATH_VERSION_STRATEGY = :path
+
+        module_function
+
+        # @param contents_per_path [Hash{String => String}] file path → source text, read by the caller
+        #   (through the trusted `IoBoundary`, so cache invalidation works).
+        # @return [Array<String>] the recognised helper-name prefixes (`["api_v3", "api_v4"]`). Empty when
+        #   the project declares no grape API — nothing changes for such a project.
+        def discover(contents_per_path)
+          declarations = {}
+          superclasses = {}
+          contents_per_path.each_value do |contents|
+            collect_from_contents(contents, declarations, superclasses)
+          rescue StandardError
+            # Best-effort: a parse failure in one grape file must not abort discovery for the rest. The core
+            # pipeline surfaces the parse error separately.
+            next
+          end
+          prefixes_for(declarations, superclasses)
+        end
+
+        # Composes `prefix` × `version` into helper-name prefixes, for grape classes only. A class with a
+        # prefix and no path-strategy version contributes the bare prefix; one with versions and no prefix
+        # contributes each version alone.
+        def prefixes_for(declarations, superclasses)
+          declarations.filter_map do |class_name, declaration|
+            next unless grape_api?(class_name, superclasses)
+
+            segments = declaration[:prefix]
+            versions = declaration[:versions]
+            next segments.join("_") if versions.empty? && !segments.empty?
+
+            versions.map { |version| (segments + [version]).join("_") }
+          end.flatten.reject(&:empty?).uniq
+        end
+
+        # Follows the recorded superclass chain (cycle-guarded) looking for a grape base. The chain lives
+        # entirely inside the scanned files, so an unresolvable parent simply ends the walk.
+        def grape_api?(class_name, superclasses)
+          seen = {}
+          current = class_name
+          while current && !seen[current]
+            seen[current] = true
+            parent = superclasses[current]
+            return true if parent && GRAPE_BASE_NAMES.include?(parent)
+
+            current = parent
+          end
+          false
+        end
+
+        def collect_from_contents(contents, declarations, superclasses)
+          root = Prism.parse(contents).value
+          walk(root, [], declarations, superclasses)
+        end
+
+        def walk(node, prefix_path, declarations, superclasses)
+          return unless node.is_a?(Prism::Node)
+
+          if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
+            name = constant_name(node.constant_path)
+            if name
+              qualified = (prefix_path + [name]).join("::")
+              record_class(node, qualified, declarations, superclasses) if node.is_a?(Prism::ClassNode)
+              walk(node.body, prefix_path + [name], declarations, superclasses) if node.body
+              return
+            end
+          end
+
+          node.compact_child_nodes.each { |child| walk(child, prefix_path, declarations, superclasses) }
+        end
+
+        def record_class(node, qualified, declarations, superclasses)
+          parent = constant_name(node.superclass)
+          superclasses[qualified] = parent if parent
+          declaration = { prefix: [], versions: [] }
+          statements_of(node.body).each { |statement| absorb_declaration(statement, declaration) }
+          declarations[qualified] = declaration unless declaration[:prefix].empty? && declaration[:versions].empty?
+        end
+
+        # `prefix :api` / `prefix 'api/v2'` (a multi-segment prefix splits on `/`), and `version 'v4'` /
+        # `version 'v4', using: :path` — both in block and non-block form.
+        def absorb_declaration(node, declaration)
+          return unless node.is_a?(Prism::CallNode) && node.receiver.nil?
+
+          case node.name
+          when :prefix
+            value = literal_value(first_argument(node))
+            declaration[:prefix] = value.split("/").reject(&:empty?) if value
+          when :version
+            value = literal_value(first_argument(node))
+            declaration[:versions] << value if value && path_strategy?(node)
+          end
+        end
+
+        # True unless an explicit `using:` names a non-path strategy. Grape defaults to `:path`.
+        def path_strategy?(node)
+          arguments = node.arguments&.arguments || []
+          keywords = arguments.find { |argument| argument.is_a?(Prism::KeywordHashNode) }
+          return true if keywords.nil?
+
+          using = keywords.elements.find do |element|
+            element.is_a?(Prism::AssocNode) && literal_value(element.key) == "using"
+          end
+          return true if using.nil?
+
+          literal_value(using.value) == PATH_VERSION_STRATEGY.to_s
+        end
+
+        def first_argument(node)
+          node.arguments&.arguments&.first
+        end
+
+        # Symbol and String literals only. A computed prefix / version is not a declaration we can ground a
+        # namespace in, so it contributes nothing.
+        def literal_value(node)
+          case node
+          when Prism::SymbolNode, Prism::StringNode then node.unescaped
+          end
+        end
+
+        def constant_name(node)
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode then constant_path_name(node)
+          end
+        end
+
+        def constant_path_name(node)
+          parent = node.parent
+          own = node.name&.to_s
+          return nil unless own
+          return own if parent.nil? # `::Foo` — a cbase root
+
+          parent_name = constant_name(parent)
+          parent_name ? "#{parent_name}::#{own}" : own
+        end
+
+        def statements_of(body)
+          case body
+          when Prism::StatementsNode then body.body
+          when Prism::BeginNode then statements_of(body.statements)
+          when nil then []
+          else [body]
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/helper_table.rb

@@ -36,7 +36,11 @@ module Rigor
         #   (`<resource>_<provider>_omniauth_(authorize|callback)_(path|url)`) whose provider segment is
         #   supplied at runtime — no per-name entry is registered for them but they MUST NOT fire
         #   `unknown-helper` either.
-        def initialize(entries, custom_helpers: [], devise_resources: [])
+        # @param grape_prefixes [Enumerable<String>] helper-name prefixes generated by `grape-path-helpers`
+        #   (`"api_v4"`), composed by {GrapeApiDiscoverer} from the project's own `prefix` / `version`
+        #   declarations. The names beyond the prefix come from grape's runtime route table and cannot be
+        #   enumerated statically, so the namespace is open — same contract as the OmniAuth family above.
+        def initialize(entries, custom_helpers: [], devise_resources: [], grape_prefixes: [])
           @entries = entries.freeze
           # Multimap: a single helper name can map to multiple entries when an uncountable-noun resource
           # registers both an arity-0 index helper and an arity-1 show helper under the same `news_path`
@@ -45,6 +49,7 @@ module Rigor
           @by_name = entries.group_by(&:name).transform_values(&:freeze).freeze
           @custom_helpers = custom_helpers.to_set.freeze
           @devise_resources = devise_resources.to_set(&:to_s).freeze
+          @grape_prefixes = grape_prefixes.to_set(&:to_s).freeze
           freeze
         end
 
@@ -67,10 +72,23 @@ module Rigor
           name = helper_name.to_s
           return true if @by_name.key?(name)
           return true if @custom_helpers.include?(name)
+          return true if grape_match?(name)
 
           omniauth_match?(name)
         end
 
+        # `<prefix>_<anything>_path` for a prefix the project's grape API declares. Only the `_path` suffix
+        # matches: `grape-path-helpers` defines no `_url` helper (its `method_missing` returns `super` unless
+        # the name ends with `_path`), so `api_v4_groups_url` is a genuine unknown helper and still fires.
+        # The bare `<prefix>_path` (the namespace root) matches too.
+        def grape_match?(name)
+          return false if @grape_prefixes.empty?
+          return false unless name.end_with?("_path")
+
+          stem = name.delete_suffix("_path")
+          @grape_prefixes.any? { |prefix| stem == prefix || stem.start_with?("#{prefix}_") }
+        end
+
         # `<resource>_<provider>_omniauth_(authorize|callback)_(path|url)` — when `<resource>` matches a
         # declared `devise_for` resource the helper is dynamic-provider Devise OmniAuth. The provider
         # segment is opaque to a static parser, so we accept any non-empty token between the resource and

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/routes_parser.rb

@@ -56,9 +56,11 @@ module Rigor
         #   draw partial from `config/routes/name.rb`. Returns file contents
         #   or nil when the file is absent.
         # @return [HelperTable]
-        def parse(contents, file_reader: nil, custom_helpers: [])
+        def parse(contents, file_reader: nil, custom_helpers: [], grape_prefixes: [])
           parse_result = Prism.parse(contents)
-          return HelperTable.new([], custom_helpers: custom_helpers) unless parse_result.errors.empty?
+          unless parse_result.errors.empty?
+            return HelperTable.new([], custom_helpers: custom_helpers, grape_prefixes: grape_prefixes)
+          end
 
           context = Context.new(file_reader: file_reader)
           interpret(parse_result.value, context)
@@ -80,7 +82,8 @@ module Rigor
               )
             ]
           end
-          HelperTable.new(paired, custom_helpers: custom_helpers, devise_resources: context.devise_resources)
+          HelperTable.new(paired, custom_helpers: custom_helpers, devise_resources: context.devise_resources,
+                                  grape_prefixes: grape_prefixes)
         end
 
         # For every registered alias rule `(from_str, to_str, arity_delta)`, find every existing entry whose
@@ -808,6 +811,12 @@ module Rigor
           # String key in the trailing keyword/options hash (its value is the `controller#action`). Without
           # this, the arity check underestimates because the placeholder count comes from a nil path.
           path = string_argument(node, 0) || hashrocket_path_key(node)
+          # `get :activity` inside a `scope(as: :user)` — NOT a resources / member / collection block (that
+          # shape returned early above), so the symbol is both the path segment (`/activity`) and the action
+          # name. Rails composes `<scope_as>_activity_path`. Fall the symbol back into the path so the
+          # name-and-arity derivation below picks it up; without it the route registered nothing and every
+          # `user_activity_path` call read as `unknown-helper`.
+          path ||= symbol_action_path(node)
           as_name = keyword_symbol(node, :as)
           return if as_name.nil? && path.nil?
 
@@ -844,6 +853,14 @@ module Rigor
           end
         end
 
+        # `/activity` for a bare `get :activity` first-arg symbol (used as both path and action name), else
+        # nil. Only reached outside a resources / member / collection block — the symbol-shorthand there is
+        # already handled as a member/collection action upstream.
+        def symbol_action_path(node)
+          symbol = symbol_argument(node, 0)
+          symbol && "/#{symbol}"
+        end
+
         # Builds the helper name for an explicit `get` / `post` / `match` route. Rails uses two distinct
         # shapes:
         #
@@ -879,12 +896,24 @@ module Rigor
 
           first_arg = node.arguments&.arguments&.first
           return true if first_arg.is_a?(Prism::SymbolNode)
-
-          # A plain action-name string with no `/` or `:` — treat it as if it were a symbol (`get 'report'`
-          # == `get :report` inside member/collection block).
-          first_arg.is_a?(Prism::StringNode) &&
-            !first_arg.unescaped.include?("/") &&
-            !first_arg.unescaped.include?(":")
+          return false unless first_arg.is_a?(Prism::StringNode)
+
+          path = first_arg.unescaped
+          # A dynamic segment (`get 'foo/:id'`) is a real path, not a plain action name — leave it to the
+          # generic explicit-route handler.
+          return false if path.include?(":")
+
+          # A bare `get '/'` (or `''`) inside a `collection do` block is the collection root, not an action
+          # shorthand — Rails names it after the enclosing resource, not `<empty>_<plural>_path`. An empty
+          # normalized action name means "not a shorthand"; fall through to the generic handler.
+          return false if path.delete_prefix("/").tr("/", "_").empty?
+
+          # A single-segment string is an action name in any resource context (`get 'report'` == `get
+          # :report`). A MULTI-segment static path (`get 'granular/new'`) is an action too, but only inside
+          # an explicit `member do` / `collection do` block, where Rails' `Mapper.normalize_name` maps the
+          # slashes to underscores (`granular_new_<scope>_<plural>_path`). Outside such a block (a bare
+          # `resources` scope) a multi-segment path is a nested custom route, so keep the generic handler.
+          !path.include?("/") || !context.innermost_action_block.nil?
         end
 
         # Generates the member / collection action helper.
@@ -893,8 +922,10 @@ module Rigor
         # Collection: `<action>_<plural_helper_prefix>path`,
         #   arity = parent_segment_count - 1 (no `:id` segment; the collection URL is /<resource>/<action>).
         def register_member_collection_action(node, context)
+          # A multi-segment string action (`get 'granular/new'` in a `collection do` block) is named by
+          # Rails via `normalize_name` — leading slash stripped, remaining slashes → underscores.
           action_name = symbol_argument(node, 0)&.to_s ||
-                        string_argument(node, 0).to_s
+                        string_argument(node, 0).to_s.delete_prefix("/").tr("/", "_")
           frame = context.innermost_action_block
           # No `member do` / `collection do` wrapper but we're inside a resources block — Rails defaults a
           # bare `<verb> :symbol` inside resources to a MEMBER action (e.g. `get :preview` →

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes.rb

@@ -5,6 +5,7 @@ require "rigor/plugin"
 require_relative "rails_routes/helper_table"
 require_relative "rails_routes/routes_parser"
 require_relative "rails_routes/helper_discoverer"
+require_relative "rails_routes/grape_api_discoverer"
 require_relative "rails_routes/analyzer"
 
 module Rigor
@@ -34,6 +35,11 @@ module Rigor
     #         config:
     #           routes_file: config/routes.rb   # default; optional
     #
+    # A project mounting a Grape API keeps its `grape-path-helpers` helpers (`api_v4_groups_badges_path`)
+    # out of `unknown-helper`: those names come from grape's runtime route table, so {GrapeApiDiscoverer}
+    # recognises the namespace their `prefix` / `version` declarations open rather than enumerating names
+    # it cannot know.
+    #
     # ## Limitations (v0.1.0)
     #
     # - `scope :path:` / `scope :module:` / `scope :as:` are not interpreted — helpers nested inside these
@@ -50,8 +56,10 @@ module Rigor
         # ':project_id', as: :project)` — path read from the `:path` keyword, not only from the positional
         # first arg; (c) detection of iterative `direct(name.sub(FROM, TO)) do ... end` alias-generation
         # idiom — generates `<TO>_*` aliases for every registered `<FROM>_*` helper. GitLab uses this to
-        # shorten `namespace_project_*` → `project_*`.
-        version: "0.27.0",
+        # shorten `namespace_project_*` → `project_*`. Bumped 2026-07-10 — recognises the open helper
+        # namespace `grape-path-helpers` generates (`api_v4_*_path`), grounded in the project's own Grape
+        # `prefix` / `version` declarations (see {GrapeApiDiscoverer}).
+        version: "0.28.0",
         description: "Validates Rails route-helper calls against `config/routes.rb`.",
         config_schema: {
           "routes_file" => { kind: :string, default: "config/routes.rb" },
@@ -63,7 +71,12 @@ module Rigor
           # `app/serializers`, `app/presenters`, `app/decorators`, not only `app/helpers/`. Walking the
           # whole tree is the honest answer to "does this `_path` / `_url` name exist anywhere in the
           # project?"; the cost is a one-time Prism parse per file at startup, which is bounded.
-          "helper_paths" => { kind: :array, default: ["app"] }
+          "helper_paths" => { kind: :array, default: ["app"] },
+          # `grape_api_paths` — the directories scanned for Grape API classes, whose `prefix` / `version`
+          # declarations ground the open `api_v4_*_path` helper namespace `grape-path-helpers` generates
+          # (see {GrapeApiDiscoverer}). Defaults cover the two conventional homes; a project with no grape
+          # API declares no prefixes and nothing changes for it.
+          "grape_api_paths" => { kind: :array, default: ["lib/api", "app/api"] }
         },
         produces: [:helper_table]
       )
@@ -73,11 +86,12 @@ module Rigor
       # routes-file edits.
       #
       # Passes a `file_reader` lambda so the parser can follow `draw(:admin)` → `config/routes/admin.rb`
-      # partials. `watch:` (ADR-60 WD3) covers every `.rb` under `helper_paths:` so ADDING a helper file
-      # invalidates the table — the producer's own in-block reads (the routes file + the partials it
-      # follows via `draw`) are captured post-compute, but a brand-new helper file the prior run never read
-      # would otherwise read as fresh.
-      producer :helper_table, watch: -> { @helper_paths.map { |dir| [dir, "**/*.rb"] } } do |_params|
+      # partials. `watch:` (ADR-60 WD3) covers every `.rb` under `helper_paths:` and `grape_api_paths:` so
+      # ADDING a helper file — or a Grape API whose `version` declaration opens a new namespace —
+      # invalidates the table. The producer's own in-block reads (the routes file + the partials it follows
+      # via `draw`) are captured post-compute, but a brand-new file the prior run never read would otherwise
+      # read as fresh.
+      producer :helper_table, watch: -> { (@helper_paths + @grape_api_paths).map { |dir| [dir, "**/*.rb"] } } do |_p|
         routes_dir = "#{File.dirname(@routes_file)}/routes"
         file_reader = lambda do |name|
           io_boundary.read_file("#{routes_dir}/#{name}")
@@ -85,13 +99,14 @@ module Rigor
           nil
         end
         contents = io_boundary.read_file(@routes_file)
-        custom_helpers = discover_custom_helpers
-        RoutesParser.parse(contents, file_reader: file_reader, custom_helpers: custom_helpers)
+        RoutesParser.parse(contents, file_reader: file_reader, custom_helpers: discover_custom_helpers,
+                                     grape_prefixes: discover_grape_prefixes)
       end
 
       def init(_services)
         @routes_file = config.fetch("routes_file")
         @helper_paths = Array(config.fetch("helper_paths")).map(&:to_s)
+        @grape_api_paths = Array(config.fetch("grape_api_paths")).map(&:to_s)
         @helper_table = nil
         @helper_table_built = false
         @load_error = nil
@@ -112,8 +127,23 @@ module Rigor
         HelperDiscoverer.discover(contents_per_path)
       end
 
-      def each_helper_file(&)
-        @helper_paths.each do |dir|
+      # Walks `grape_api_paths:` through the trusted `IoBoundary` and returns the helper-name prefixes the
+      # project's Grape API classes generate (`["api_v3", "api_v4"]`). Empty for a project with no grape API,
+      # which leaves `unknown-helper` behaviour exactly as it was.
+      def discover_grape_prefixes
+        contents_per_path = {}
+        each_ruby_file(@grape_api_paths) do |path|
+          contents_per_path[path] = io_boundary.read_file(path)
+        rescue Plugin::AccessDeniedError, Errno::ENOENT
+          next
+        end
+        GrapeApiDiscoverer.discover(contents_per_path)
+      end
+
+      def each_helper_file(&) = each_ruby_file(@helper_paths, &)
+
+      def each_ruby_file(dirs, &)
+        dirs.each do |dir|
           absolute = File.expand_path(dir)
           next unless File.directory?(absolute)
 

data/sig/rigor/environment.rbs

@@ -29,6 +29,7 @@ module Rigor
     def rbs_module?: (String | Symbol name) -> bool
     def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
     def reflection: () -> untyped?
+    def missing_rbs_gem_owner: (String | Symbol root_constant_name) -> String?
 
     class ClassRegistry
       def self.default: () -> ClassRegistry

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - Rigor contributors
@@ -301,8 +301,10 @@ files:
 - data/builtins/ruby_core/string.yml
 - data/builtins/ruby_core/struct.yml
 - data/builtins/ruby_core/time.yml
+- data/core_overlay/csv.rbs
 - data/core_overlay/numeric.rbs
 - data/core_overlay/pathname.rbs
+- data/core_overlay/psych.rbs
 - data/core_overlay/string_scanner.rbs
 - data/gem_overlay/activesupport/core_ext.rbs
 - data/vendored_gem_sigs/ast/ast.rbs
@@ -484,6 +486,7 @@ files:
 - lib/rigor/cli/plugins_command.rb
 - lib/rigor/cli/plugins_renderer.rb
 - lib/rigor/cli/prism_colorizer.rb
+- lib/rigor/cli/protection_fork_scan.rb
 - lib/rigor/cli/protection_renderer.rb
 - lib/rigor/cli/protection_report.rb
 - lib/rigor/cli/renderable.rb
@@ -511,6 +514,7 @@ files:
 - lib/rigor/environment/constant_type_cache_holder.rb
 - lib/rigor/environment/hkt_registry_holder.rb
 - lib/rigor/environment/lockfile_resolver.rb
+- lib/rigor/environment/missing_gem_constant_index.rb
 - lib/rigor/environment/rbs_collection_discovery.rb
 - lib/rigor/environment/rbs_coverage_report.rb
 - lib/rigor/environment/rbs_hierarchy.rb
@@ -555,6 +559,7 @@ files:
 - lib/rigor/inference/fallback.rb
 - lib/rigor/inference/fallback_tracer.rb
 - lib/rigor/inference/flow_tracer.rb
+- lib/rigor/inference/fork_map.rb
 - lib/rigor/inference/hkt_body.rb
 - lib/rigor/inference/hkt_body_parser.rb
 - lib/rigor/inference/hkt_reducer.rb
@@ -747,6 +752,7 @@ files:
 - 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/lib/rigor/plugin/activerecord/structure_sql_parser.rb
 - plugins/rigor-activerecord/sig/active_record/relation.rbs
 - plugins/rigor-activestorage/lib/rigor-activestorage.rb
 - plugins/rigor-activestorage/lib/rigor/plugin/activestorage.rb
@@ -802,6 +808,7 @@ files:
 - plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/analyzer.rb
 - plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/devise_routes.rb
 - plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/doorkeeper_routes.rb
+- plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/grape_api_discoverer.rb
 - plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/helper_discoverer.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