rigortype 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 749e0e15c9b85dcec97c9afc1b107d5ebc1a1a685cc19aa39d316a9826992d4a
-  data.tar.gz: 45bcee26284594e35b51a050ce8ac234935bee954063b50fdfe1b0c6a9bcddea
+  metadata.gz: ce4071258582638c452079484534e58c6d6b290a88ea51fdce715024d7c09297
+  data.tar.gz: 90197cb4711899857c8d242470b063e7da64947e46e240253206179a0e8f6baf
 SHA512:
-  metadata.gz: fbf022b6e92a96e1c095cb3d887936161e836201662f051c60de5d0d78494f263228a28df509c3b937768735b5ce18162ee28657b2aaf1cd7a8b2d4851338a53
-  data.tar.gz: a49e89a07950f54fcf8f38e328b8fdb658aaf0802154df457c7b9b1370f35279c1d6d5fe3acf6a45c9e49ff2f7c09ff9f209b1f7dab68d20b283c9baa4b2760b
+  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/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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.2.4"
+  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.4
+  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: []