rigortype 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 775a0b6e3050294352d505366428814ab73348d2ced5ccf45842644c38752155
-  data.tar.gz: 7ec72c4aa56cbb43ae18dd3c1a029da3bb6746a604c4a3d72811b34b5d1c1439
+  metadata.gz: ce4071258582638c452079484534e58c6d6b290a88ea51fdce715024d7c09297
+  data.tar.gz: 90197cb4711899857c8d242470b063e7da64947e46e240253206179a0e8f6baf
 SHA512:
-  metadata.gz: cc0650acb783740184fb76f0c5382fefe3950bd84011c84ccd2e23a60ff703519de94a294b39e96e11198748b2539917fae117972be7366dd06725ee54975935
-  data.tar.gz: d06b60ff922cfb4ab77ea680b5d624702a4f782b65c1dcb2e3f631793fe90cb4bb8302d50ac5a3656cbd1a1fe79e198cfee9c8641b037acf48906ae1aa63eeb8
+  metadata.gz: 4e967fdc0ca679a712860a20da09842c2668727c0068a4ed9657ae4111d0d94a5ab8efa9684c1a75b1ad25dbeb03efd9a4580f85e771aa5a61a05f56f38b6203
+  data.tar.gz: 8773e6364390cb36296345c4ec8974cee5bec585f7f9da292950859e4cb754081a68130db00dbc14f62d77c7f396477adace7480500d789bb838777ea268c6a2

data/docs/manual/plugins/rigor-rails-i18n.md

@@ -43,9 +43,14 @@ errors_demo.rb:25:1: warning: `t('errors.messages.blank')` is missing from local
 with a literal first argument. **Lazy keys** — `t('.title')` in a
 controller — are expanded to `<controller_scope>.<action>.<key>`
 from the file path and the innermost enclosing `def`, matching
-Rails' convention; lazy keys in non-controller files are skipped
-(the scope can't be determined statically). Calls with a
-non-literal key (`t(some_variable)`) pass through unchecked.
+Rails' convention; lazy keys in non-controller Ruby files (models,
+helpers, mailers) are skipped (the scope can't be determined
+statically at that point). **View template lazy keys** —
+`t('.title')` inside `app/views/setting/index.html.erb` expands
+to `setting.index.title` and is validated for key existence and
+per-locale coverage; ERB, Haml, and Slim templates under
+`view_search_paths` (default `app/views`) are scanned. Calls with
+a non-literal key (`t(some_variable)`) pass through unchecked.
 
 Keys under the prefixes Rails and the `rails-i18n` gem ship
 themselves (`date.` / `time.` / `datetime.` / `number.` /
@@ -62,11 +67,14 @@ plugins:
     config:
       locale_search_paths: ["config/locales"]   # default
       configured_locales: ["en"]                # default
+      view_search_paths: ["app/views"]          # default
 ```
 
 `configured_locales` is the set of locales the project ships;
 setting it to `["en", "ja"]` turns on `missing-locale` warnings
 whenever a key resolves in one but not the other.
+`view_search_paths` controls which directories are scanned for
+view templates containing lazy `t('.key')` calls.
 
 ## Limitations
 
@@ -74,6 +82,17 @@ whenever a key resolves in one but not the other.
 - **Lazy keys outside controllers are skipped** — the
   controller/action scope `t('.x')` depends on isn't derivable in
   a model / helper / mailer.
+- **View template lazy keys** (`t('.key')` inside ERB / Haml /
+  Slim) are validated for key existence and per-locale coverage.
+  Interpolation validation is skipped for templates — the hash
+  may come from controller instance variables not visible in the
+  template source. Configure `view_search_paths:` to override the
+  default `["app/views"]`.
+- **View diagnostics duplicate under `--workers`** — the view
+  scan is a project-wide pass surfaced through the per-file
+  diagnostic hook, so each fork-pool worker re-emits the full set
+  (the same once-per-run limitation the `load-error` diagnostics
+  carry). Default `rigor check` (sequential) is unaffected.
 - **Pluralization is recognised but not validated** — `count:` is
   treated as a reserved option; whether the locale defines
   `:zero` / `:one` / `:other` is not checked.

data/lib/rigor/analysis/diagnostic.rb

@@ -47,6 +47,9 @@ module Rigor
       def initialize(path:, line:, column:, message:, severity: :error, rule: nil, # rubocop:disable Metrics/ParameterLists
                      source_family: DEFAULT_SOURCE_FAMILY,
                      receiver_type: nil, method_name: nil, project_definition_site: nil)
+        raise ArgumentError, "line must be >= 1, got #{line}" if line < 1
+        raise ArgumentError, "column must be >= 1, got #{column}" if column < 1
+
         @path = path
         @line = line
         @column = column

data/lib/rigor/analysis/incremental_session.rb

@@ -35,9 +35,14 @@ module Rigor
 
       # @param paths [Array<String>, nil] explicit analysis roots; nil
       #   (the default) uses the configuration's `paths:`.
-      def initialize(configuration:, paths: nil)
+      # @param environment [Rigor::Environment, nil] optional shared
+      #   environment to thread into each internal Runner. Long-lived
+      #   callers and specs can use this to avoid rebuilding the same
+      #   RBS universe for every baseline / recheck / oracle run.
+      def initialize(configuration:, paths: nil, environment: nil)
         @configuration = configuration
         @paths = paths
+        @environment = environment
         @cache = {}              # analyzed path => [Diagnostic]
         @sources = {}            # analyzed path => Set<source path it read from>
         @digests = {}            # analyzed path => content digest at last analysis
@@ -312,7 +317,7 @@ module Rigor
       end
 
       def build_runner(**)
-        Runner.new(configuration: @configuration, cache_store: nil, **)
+        Runner.new(configuration: @configuration, cache_store: nil, environment: @environment, **)
       end
 
       # Run the runner over the session's explicit paths (or, when none were

data/lib/rigor/cli/skill_describe.rb

@@ -208,8 +208,14 @@ module Rigor
           ["rigor-rbs-setup", "your gems ship no community RBS yet — install it so Rigor stops typing them as Dynamic."]
         elsif state.fetch(:ci) != :wired
           ["rigor-ci-setup", "Rigor is configured but not wired into CI — lock in the regression guard."]
-        elsif state.fetch(:baseline)
-          ["rigor-baseline-reduce", "a baseline is in place — work it down rule by rule."]
+        # A present baseline is deliberately NOT a recommendation trigger.
+        # A baseline is a healthy, finished onboarding state, not a problem to
+        # work off; pushing every baselined project to "reduce it" turns a
+        # working build into a chore and tempts scattering `# rigor:disable`
+        # through the code to make a number go down — means over ends.
+        # `rigor-baseline-reduce` stays in the catalogue for the intermediate
+        # user who *chooses* to invest in it; the headline routes to genuinely
+        # additive steps instead.
         elsif state.fetch(:editor) == :unwired
           ["rigor-editor-setup",
            "you have an editor config but no Rigor LSP — wire `rigor lsp` for live diagnostics and hover types."]
@@ -297,7 +303,6 @@ module Rigor
           The recommendation above is from a presence-only probe — it does not run
           `rigor check`. If you have run (or now run) `rigor check`, let its findings
           refine the choice:
-          - errors present and no baseline yet → rigor-baseline-reduce
           - a `call.unresolved-toplevel` / `call.undefined-method` cluster on the
             project's own monkey-patches → rigor-monkeypatch-resolve
           - framework calls (ActiveRecord, routes, i18n …) typing as Dynamic with no

data/lib/rigor/environment/rbs_loader.rb

@@ -170,7 +170,7 @@ module Rigor
           source = missing.map { |name| "module #{name}\nend\n" }.join
           buffer = ::RBS::Buffer.new(name: SYNTHETIC_NAMESPACE_BUFFER, content: source)
           _, directives, decls = ::RBS::Parser.parse_signature(buffer)
-          env.add_source(::RBS::Source::RBS.new(buffer, directives || [], decls || []))
+          add_parsed_decls(env, buffer, directives, decls)
         rescue ::RBS::BaseError
           # Fail-soft: synthesis is an opportunistic uplift, never a
           # hard requirement. A parse failure here just leaves the env
@@ -232,11 +232,52 @@ module Rigor
           missing.uniq
         end
 
+        # Normalises a `class_decls` entry's representative declaration
+        # across the gemspec's supported RBS range (`rbs >= 3.0, < 5.0`).
+        # RBS 4.x exposes it as `entry.primary_decl` (the AST declaration
+        # directly); RBS 3.x exposes `entry.primary` (a wrapper whose
+        # `#decl` is the AST declaration). Returns the AST declaration, or
+        # nil when neither accessor is present. Without this guard,
+        # `class_decl_paths` crashed under RBS 3.x with
+        # `undefined method 'primary_decl'`.
+        def primary_decl_for(entry)
+          if entry.respond_to?(:primary_decl)
+            entry.primary_decl
+          elsif entry.respond_to?(:primary)
+            primary = entry.primary
+            primary.respond_to?(:decl) ? primary.decl : primary
+          end
+        end
+
+        # Appends freshly-parsed declarations to an `RBS::Environment`
+        # across the gemspec's supported RBS range (`rbs >= 3.0, < 5.0`).
+        # RBS 4.x wraps the declarations in an `RBS::Source::RBS` and
+        # takes them through `env.add_source`; RBS 3.x has neither
+        # `RBS::Source` nor `add_source` and instead registers them with
+        # `env.add_signature(buffer:, directives:, decls:)` (a bare
+        # `env << decl` is NOT enough — it skips the `signatures` table
+        # that `resolve_type_names` rebuilds from, so the synthesized
+        # declarations silently vanish on resolve). Without this guard
+        # the synthesis paths (`synthesize_missing_namespaces`,
+        # `append_stub_declarations`, `add_virtual_rbs`) crashed under
+        # RBS 3.x with `uninitialized constant RBS::Source`.
+        def add_parsed_decls(env, buffer, directives, decls)
+          decls ||= []
+          directives ||= []
+          if env.respond_to?(:add_source)
+            env.add_source(::RBS::Source::RBS.new(buffer, directives, decls))
+          elsif env.respond_to?(:add_signature)
+            env.add_signature(buffer: buffer, directives: directives, decls: decls)
+          else
+            decls.each { |decl| env << decl }
+          end
+        end
+
         # True when a `class_decls` entry was declared in one of the
         # project's own signature files (by declaration location), so
         # the sweep skips the bundled stdlib / vendored universe.
         def project_entry?(entry, project_files)
-          decl = entry.respond_to?(:primary_decl) ? entry.primary_decl : nil
+          decl = primary_decl_for(entry)
           location = decl&.location
           buffer_name = location&.buffer&.name
           return false unless buffer_name
@@ -262,7 +303,7 @@ module Rigor
           end.join
           buffer = ::RBS::Buffer.new(name: SYNTHETIC_STUB_BUFFER, content: source)
           _, directives, decls = ::RBS::Parser.parse_signature(buffer)
-          base_env.add_source(::RBS::Source::RBS.new(buffer, directives || [], decls || []))
+          add_parsed_decls(base_env, buffer, directives, decls)
         rescue ::RBS::BaseError
           nil
         end
@@ -284,8 +325,7 @@ module Rigor
 
             buffer = ::RBS::Buffer.new(name: filename.to_s, content: content.to_s)
             _, directives, decls = ::RBS::Parser.parse_signature(buffer)
-            source = ::RBS::Source::RBS.new(buffer, directives || [], decls || [])
-            env.add_source(source)
+            add_parsed_decls(env, buffer, directives, decls)
           rescue ::RBS::BaseError
             # WD6 fail-soft: a single broken virtual RBS contribution
             # does not pull the whole env down. The plugin layer
@@ -589,7 +629,7 @@ module Rigor
 
         result = {}
         env.class_decls.each do |rbs_name, entry|
-          decl = entry.primary_decl
+          decl = self.class.primary_decl_for(entry)
           next if decl.nil?
 
           location = decl.location
@@ -911,12 +951,17 @@ module Rigor
       end
 
       # Collects the AST declaration nodes behind a `class_decls`
-      # entry. RBS 4's `ModuleEntry` / `ClassEntry` expose `each_decl`;
-      # the older single-`decl` shape is handled defensively so the
-      # loader survives an rbs-gem minor bump.
+      # entry across the supported RBS range (`rbs >= 3.0, < 5.0`).
+      # RBS 4's `ModuleEntry` / `ClassEntry` expose `each_decl` yielding
+      # bare AST declarations; RBS 3.x exposes `decls`, an array of
+      # `MultiEntry::D` wrappers whose `#decl` is the AST declaration.
+      # The single-`decl` shape is handled defensively so the loader
+      # survives an rbs-gem minor bump.
       def entry_declarations(entry)
         if entry.respond_to?(:each_decl)
           [].tap { |acc| entry.each_decl { |decl| acc << decl } }
+        elsif entry.respond_to?(:decls)
+          entry.decls.map { |d| d.respond_to?(:decl) ? d.decl : d }
         elsif entry.respond_to?(:decl)
           [entry.decl]
         else

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.2.3"
+  VERSION = "0.2.5"
 end

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/analyzer.rb

@@ -42,6 +42,32 @@ module Rigor
         # `_controller.rb` (e.g. `users`, `admin/users`).
         CONTROLLER_PATH_RE = %r{(?:^|/)controllers/(.+)_controller\.rb$}
 
+        # Matches Rails view-template file paths to derive the
+        # I18n "virtual path" — the scope that Rails uses for
+        # lazy `t('.key')` lookups inside a template.
+        #
+        # Captures the path segment between `views/` and the
+        # format+variant+handler suffix, then strips a leading
+        # underscore from each segment — Rails templates resolve
+        # `_form.html.erb` as "form", not "_form".
+        #
+        #   app/views/setting/index.html.erb      → setting.index
+        #   app/views/admin/users/new.html.erb    → admin.users.new
+        #   app/views/home/index.html+mobile.erb  → home.index
+        #   app/views/users/_form.html.erb        → users.form
+        #
+        # The view-scope lazy expansion replaces the action
+        # part with the view's virtual path:
+        #   `<%= t('.title') %>` → `setting.index.title`
+        VIEW_SCOPE_RE = %r{views/(.+?)\.(?:\w+)(?:\+\w+)?\.\w+\z}
+
+        # Regex to extract lazy-key arguments from ERB / HTML
+        # template content. Matches `t('.key')`, `t(".key")`,
+        # `I18n.t('.key')`, and `I18n.translate('.key')` with a
+        # leading dot on the key string. Captures only the key
+        # part after the dot.
+        LAZY_T_KEY_RE = /\b(?:I18n\.)?(?:t|translate)\s*\(\s*(?:"\.([^"\\]*)"|'\.([^'\\]*)')/
+
         # Reserved option keys — these are recognised by I18n
         # itself and not treated as interpolation variables.
         RESERVED_OPTION_KEYS = %i[
@@ -146,6 +172,32 @@ module Rigor
           m[1].tr("/", ".")
         end
 
+        def view_scope_from_path(path)
+          m = VIEW_SCOPE_RE.match(path.to_s)
+          return nil unless m
+
+          m[1].split("/").map { |seg| seg.sub(/\A_/, "") }.join(".")
+        end
+
+        def extract_lazy_keys_from_erb(content)
+          content.scan(LAZY_T_KEY_RE).map { |dq, sq| dq || sq }.uniq
+        end
+
+        def validate_view_key(key, locale_index:, configured_locales:)
+          entry = locale_index.find(key)
+          if entry.nil?
+            return [] if locale_index.pluralization_namespace?(key)
+            return [] if rails_shipped_key?(key)
+
+            return [unknown_key_violation(key, locale_index)]
+          end
+
+          violations = [translation_call_info(key, entry)]
+          missing = locale_index.missing_locales_for(key, configured_locales: configured_locales)
+          violations << missing_locale_violation(key, missing) unless missing.empty?
+          violations
+        end
+
         # Expands a lazy key (starting with `.`) to its full
         # dotted path using the controller scope and action name.
         # Returns the raw key unchanged for absolute keys.

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n.rb

@@ -26,6 +26,7 @@ module Rigor
     #         config:
     #           locale_search_paths: ["config/locales"]   # default; optional
     #           configured_locales: ["en"]                # default; optional — locales the project ships
+    #           view_search_paths: ["app/views"]          # default; optional — view template search roots
     #
     # ## What it checks
     #
@@ -39,6 +40,11 @@ module Rigor
     #    `%{var}` placeholders must match the call's keyword
     #    arguments. Missing placeholders are errors; extra
     #    arguments are warnings.
+    # 4. **View template lazy keys** — `t('.title')` inside
+    #    `app/views/setting/index.html.erb` expands to
+    #    `setting.index.title` and is validated against the
+    #    locale index. ERB, Haml, and Slim templates are
+    #    scanned under `view_search_paths`.
     #
     # ## Limitations
     #
@@ -51,6 +57,16 @@ module Rigor
     #   Lazy keys in non-controller `.rb` files (models, helpers,
     #   mailers, …) are silently skipped — the controller/action
     #   scope cannot be statically determined there.
+    # - View template lazy keys (`t('.key')` inside ERB / Haml /
+    #   Slim) are validated for key existence and per-locale
+    #   coverage. Interpolation variable validation is skipped
+    #   for view templates (the hash may come from controller
+    #   instance variables not visible in the template).
+    #   The view scan is a project-wide pass surfaced through the
+    #   per-file diagnostic hook, so under `--workers` each
+    #   fork-pool worker re-emits the full set (the same
+    #   once-per-run limitation the `load-error` path carries);
+    #   sequential `rigor check` is unaffected.
     # - Pluralization (`t('errors.messages.too_short',
     #   count: n)`) is recognised at the call site but the
     #   `count` key is not used to validate the locale's
@@ -61,14 +77,15 @@ module Rigor
     class RailsI18n < Rigor::Plugin::Base
       manifest(
         id: "rails-i18n",
-        # Bumped 2026-05-28 — skip `unknown-key` on Rails / rails-
-        # i18n shipped defaults (`date.order`, `time.am`,
-        # `support.array.*`, `errors.format`, …).
-        version: "0.2.0",
+        # Bumped 2026-06-23 — view template lazy-key scanning
+        # (`t('.key')` inside ERB / Haml / Slim under
+        # `view_search_paths`).
+        version: "0.3.0",
         description: "Validates I18n `t(key)` calls against `config/locales/*.yml`.",
         config_schema: {
           "locale_search_paths" => { kind: :array, default: ["config/locales"] },
-          "configured_locales" => { kind: :array, default: ["en"] }
+          "configured_locales" => { kind: :array, default: ["en"] },
+          "view_search_paths" => { kind: :array, default: ["app/views"] }
         }
       )
 
@@ -88,22 +105,49 @@ module Rigor
         index
       end
 
+      # Scans view templates under `view_search_paths` for lazy
+      # `t('.key')` / `I18n.translate('.key')` calls and validates
+      # each expanded key against the locale index. Interpolation
+      # validation is skipped — the hash may come from controller
+      # instance variables not visible in the template source.
+      #
+      # Watches `**/*.{erb,haml,slim}` under each search root so
+      # the cache invalidates when templates are edited.
+      producer :view_diagnostics, watch: -> { [[@view_search_paths, "**/*.erb", "**/*.haml", "**/*.slim"]] } do |_params|
+        index = producer_value(:locale_index)
+        next [] if index.nil? || index.empty?
+
+        scan_view_files(index)
+      end
+
       def init(_services)
         @locale_search_paths = Array(config.fetch("locale_search_paths")).map(&:to_s)
+        @view_search_paths = Array(config.fetch("view_search_paths")).map(&:to_s)
         @configured_locales = Array(config.fetch("configured_locales")).map(&:to_s)
         @load_errors = []
         @load_errors_emitted = false
+        @view_diagnostics_emitted = false
       end
 
       # File-level only: the once-per-run YAML load errors + the
-      # runtime (cache-load) error. Per-call `t('key')` validation runs
-      # over the engine-owned walk via the node_rule below (ADR-37). The
-      # locale index is lazily loaded + memoised by `producer_value`.
+      # runtime (cache-load) error + the view-template scan. Per-call
+      # `t('key')` validation runs over the engine-owned walk via the
+      # node_rule below (ADR-37). The locale index and view diagnostics
+      # are lazily loaded + memoised by `producer_value`.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = producer_value(:locale_index)
         diagnostics = []
         diagnostics.concat(consume_load_error_diagnostics(path)) unless @load_errors.empty?
         diagnostics << runtime_error_diagnostic(path) if index.nil? && producer_error(:locale_index)
+        unless @view_diagnostics_emitted
+          view_diags = producer_value(:view_diagnostics) || []
+          if (view_err = producer_error(:view_diagnostics))
+            diagnostics << view_runtime_error_diagnostic(path, view_err)
+          else
+            diagnostics.concat(view_diags)
+          end
+          @view_diagnostics_emitted = true
+        end
         diagnostics
       end
 
@@ -126,6 +170,68 @@ module Rigor
 
       private
 
+      def scan_view_files(index)
+        view_files.flat_map do |view_path|
+          scan_view_file(view_path, index)
+        end
+      end
+
+      def scan_view_file(view_path, index)
+        content = read_view_template(view_path) or return []
+        scope = Analyzer.view_scope_from_path(view_path) or return []
+
+        display_path = relative_view_path(view_path)
+        Analyzer.extract_lazy_keys_from_erb(content).flat_map do |key|
+          full_key = "#{scope}.#{key}"
+          Analyzer.validate_view_key(
+            full_key, locale_index: index, configured_locales: @configured_locales
+          ).map { |v| view_diagnostic(display_path, v) }
+        end
+      rescue StandardError => e
+        [Rigor::Analysis::Diagnostic.new(
+          path: relative_view_path(view_path), line: 1, column: 1,
+          message: "rigor-rails-i18n: failed to scan view template: #{e.class}: #{e.message}",
+          severity: :warning,
+          rule: "load-error"
+        )]
+      end
+
+      def view_files
+        @view_search_paths.flat_map do |root|
+          absolute = File.expand_path(root)
+          next [] unless File.directory?(absolute)
+
+          Dir.glob(File.join(absolute, "**", "*.{erb,haml,slim}"))
+        end.sort
+      end
+
+      # Diagnostics anchor on a path relative to the working
+      # directory — the same base `File.expand_path` globbed the
+      # view files against — so view diagnostics render and match
+      # baselines like every other diagnostic (which carry
+      # project-relative paths). Falls back to the absolute path
+      # for a view outside the working tree.
+      def relative_view_path(absolute_path)
+        Pathname.new(absolute_path).relative_path_from(Pathname.pwd).to_s
+      rescue ArgumentError
+        absolute_path
+      end
+
+      def read_view_template(path)
+        io_boundary.read_file(path)
+      rescue Plugin::AccessDeniedError
+        nil
+      end
+
+      def view_diagnostic(view_path, violation)
+        Rigor::Analysis::Diagnostic.new(
+          path: view_path, line: 1, column: 1,
+          message: violation.message,
+          severity: violation.severity,
+          rule: violation.rule
+        )
+      end
+
       # The runner only invokes `diagnostics_for_file` for
       # Ruby files (`paths:` is filtered to `.rb`). YAML
       # parse errors therefore can't be anchored on the
@@ -155,6 +261,15 @@ module Rigor
           rule: "load-error"
         )
       end
+
+      def view_runtime_error_diagnostic(path, error)
+        Rigor::Analysis::Diagnostic.new(
+          path: path, line: 1, column: 1,
+          message: "rigor-rails-i18n: failed to scan view templates: #{error.class}: #{error.message}",
+          severity: :warning,
+          rule: "load-error"
+        )
+      end
     end
 
     Rigor::Plugin.register(RailsI18n)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Rigor contributors
 bindir: exe
 cert_chain: []
-date: 1980-01-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -109,6 +109,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: binpacker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: parallel_tests
   requirement: !ruby/object:Gem::Requirement
@@ -934,7 +954,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Inference-first static analysis for Ruby.
 test_files: []