rigortype 0.2.4 → 0.2.6

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)

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

@@ -110,7 +110,7 @@ module Rigor
       # ADR-37 slice 2 — matcher narrowing
       # (`expect(x).to be_a(T)` → `post_return_facts` on `x`),
       # method-gated by the engine on the expectation verbs.
-      type_specifier methods: %i[to not_to to_not] do |call_node, scope|
+      narrowing_facts methods: %i[to not_to to_not] do |call_node, scope|
         MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
 

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

@@ -169,13 +169,13 @@ module Rigor
       end
 
       # ADR-52 slice 4 — `T.bind(self, T)`'s self-narrowing fact,
-      # contributed via the method-gated `type_specifier` DSL. The
+      # contributed via the method-gated `narrowing_facts` DSL. The
       # statement evaluator consults this path for narrowing facts.
       # The return-type half (`Constant[nil]`) flows through the
       # `dynamic_return` rule above; the block re-checks the `T.`
       # receiver via the recogniser, so an unrelated `bind` call
       # contributes nothing.
-      type_specifier methods: [:bind] do |call_node, scope|
+      narrowing_facts methods: [:bind] do |call_node, scope|
         bind_post_return_facts(call_node, scope)
       end
 
@@ -258,7 +258,7 @@ module Rigor
         lookup_signature(call_node, scope)&.return_type
       end
 
-      # The `type_specifier` body for `T.bind` — same sigil gate as
+      # The `narrowing_facts` body for `T.bind` — same sigil gate as
       # the return-type path, then the recogniser's
       # `post_return_facts` (the `Fact(target_kind: :self)` that
       # narrows `scope.self_type` for the rest of the block).

data/sig/rigor/plugin/base.rbs

@@ -26,6 +26,8 @@ class Rigor::Plugin::Base
   def self.dynamic_return: (?receivers: (Array[String] | ^() -> Array[String])?, ?methods: (Array[untyped] | ^() -> Array[untyped])?) { (untyped call_node, untyped scope) -> untyped } -> nil
   def self.dynamic_returns: () -> Array[untyped]
 
+  def self.narrowing_facts: (methods: Array[untyped]) { (untyped call_node, untyped scope) -> untyped } -> nil
+  # Deprecating alias for `narrowing_facts` (ADR-80); removed in 0.3.0.
   def self.type_specifier: (methods: Array[untyped]) { (untyped call_node, untyped scope) -> untyped } -> nil
   def self.type_specifiers: () -> Array[untyped]
 

data/sig/rigor/scope.rbs

@@ -8,6 +8,7 @@ module Rigor
     attr_reader cvars: Hash[Symbol, Type::t]
     attr_reader globals: Hash[Symbol, Type::t]
     attr_reader discovery: DiscoveryIndex
+    attr_reader dynamic_origins: Hash[untyped, Symbol]
     attr_reader indexed_narrowings: Hash[IndexedKey, Type::t]
     attr_reader method_chain_narrowings: Hash[ChainKey, Type::t]
     attr_reader source_path: String?
@@ -32,6 +33,7 @@ module Rigor
     def data_member_layouts: () -> Hash[String, Array[Symbol]]
     def struct_member_layouts: () -> Hash[String, { members: Array[Symbol], keyword_init: bool }]
     def param_inferred_types: () -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
+    def record_dynamic_origin: (untyped node, Symbol cause) -> Scope
 
     class DiscoveryIndex
       attr_reader declared_types: Hash[untyped, Type::t]
@@ -71,7 +73,7 @@ module Rigor
 
     def self.empty: (?environment: Environment, ?source_path: String?) -> Scope
 
-    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?discovery: DiscoveryIndex, ?source_path: String?) -> void
+    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?discovery: DiscoveryIndex, ?source_path: String?, ?dynamic_origins: Hash[untyped, Symbol]) -> void
     def with_source_path: (String? path) -> Scope
     def with_struct_fold_safe: (Set[Symbol] locals) -> Scope
     def struct_fold_safe?: (String | Symbol name) -> bool

data/skills/rigor-plugin-author/SKILL.md

@@ -97,19 +97,22 @@ AST walk per file — hands every matching node to the block along with a
 `scope` it can query for inferred types. The block returns an array of
 `Rigor::Analysis::Diagnostic` (built via the `diagnostic` helper).
 Optionally the plugin also declares `dynamic_return(receivers:)` /
-`type_specifier(methods:)` to *supply* a return type or narrowing facts
-for call sites the core analyzer types as `Dynamic`. `#diagnostics_for_file`
+`narrowing_facts(methods:)` to *supply* a return type or narrowing facts
+for call sites the core analyzer types as `Dynamic`. (`narrowing_facts`
+was renamed from `type_specifier` in ADR-80; `type_specifier` remains as a
+deprecating alias removed in 0.3.0 — use `narrowing_facts` in new plugins.)
+`#diagnostics_for_file`
 is the file-rule surface for whole-file diagnostics a per-node walk can't
 express. (`flow_contribution_for` was removed pre-1.0 in ADR-52 WD3 —
 defining it now raises `ArgumentError`; use `dynamic_return` /
-`type_specifier`. See Phase 2.)
+`narrowing_facts`. See Phase 2.)
 
 ## Phase outline
 
 | Phase | What | Reference |
 | --- | --- | --- |
 | 1 | Package and scaffold — gem vs project-private layout, gemspec / Gemfile, the plugin class skeleton, `.rigor.yml` activation. | [`references/01-plan-and-scaffold.md`](references/01-plan-and-scaffold.md) |
-| 2 | Node rules — `node_rule` (engine-owned walk), building `Diagnostic`s via `Base#diagnostic`, querying `scope.type_of`, calling the target library directly instead of reimplementing it (ADR-39: `Plugin::Inflector`, `Base.suggest`), optional `dynamic_return` / `type_specifier`, RBS for the DSL. | [`references/02-walker-and-types.md`](references/02-walker-and-types.md) |
+| 2 | Node rules — `node_rule` (engine-owned walk), building `Diagnostic`s via `Base#diagnostic`, querying `scope.type_of`, calling the target library directly instead of reimplementing it (ADR-39: `Plugin::Inflector`, `Base.suggest`), optional `dynamic_return` / `narrowing_facts`, RBS for the DSL. | [`references/02-walker-and-types.md`](references/02-walker-and-types.md) |
 | 3 | Test and ship — fixture-based tests (RSpec / Minitest, no rigor internals), version pinning, README, publish or keep private. | [`references/03-test-and-ship.md`](references/03-test-and-ship.md) |
 
 ## Reading order — modules
@@ -117,5 +120,5 @@ defining it now raises `ArgumentError`; use `dynamic_return` /
 | Module | Read | Covers |
 | --- | --- | --- |
 | 1 | [`references/01-plan-and-scaffold.md`](references/01-plan-and-scaffold.md) | **Phase 1.** The gem vs project-private packaging split, directory trees for both, gemspec template, project-private path-gem / `RUBYLIB` activation, the `Rigor::Plugin::Base` skeleton, `.rigor.yml` `plugins:` wiring. |
-| 2 | [`references/02-walker-and-types.md`](references/02-walker-and-types.md) | **Phase 2.** The `node_rule` engine-owned AST walk over Prism nodes, the `Base#diagnostic` helper, asking the analyzer for inferred types via `scope.type_of`, two-pass / lexical context (`node_file_context` / `NodeContext`), the optional `dynamic_return` / `type_specifier` return-type hooks (`flow_contribution_for` was removed pre-1.0 in ADR-52 WD3), calling the target library's pure methods directly rather than reimplementing them (ADR-39: `Plugin::Inflector` over the real `ActiveSupport::Inflector`; `Base.suggest` for did-you-mean), and shipping `sig/*.rbs` so the DSL's types are visible. |
+| 2 | [`references/02-walker-and-types.md`](references/02-walker-and-types.md) | **Phase 2.** The `node_rule` engine-owned AST walk over Prism nodes, the `Base#diagnostic` helper, asking the analyzer for inferred types via `scope.type_of`, two-pass / lexical context (`node_file_context` / `NodeContext`), the optional `dynamic_return` / `narrowing_facts` return-type hooks (`narrowing_facts` was renamed from `type_specifier` in ADR-80, alias removed in 0.3.0; `flow_contribution_for` was removed pre-1.0 in ADR-52 WD3), calling the target library's pure methods directly rather than reimplementing them (ADR-39: `Plugin::Inflector` over the real `ActiveSupport::Inflector`; `Base.suggest` for did-you-mean), and shipping `sig/*.rbs` so the DSL's types are visible. |
 | 3 | [`references/03-test-and-ship.md`](references/03-test-and-ship.md) | **Phase 3.** Testing a plugin from outside the monorepo — fixture projects driven through `rigor check --format json`, plus pure unit tests of dispatch tables — with RSpec or Minitest. Version pinning against the pre-1.0 contract. README. Publishing to RubyGems or keeping the plugin private. |

data/skills/rigor-plugin-author/references/02-walker-and-types.md

@@ -162,7 +162,7 @@ rather than hand-rolling Levenshtein:
 Rigor::Plugin::Base.suggest(typo, known_names)  # nearest match, or nil
 ```
 
-## Optional — contribute a return type with `dynamic_return` / `type_specifier`
+## Optional — contribute a return type with `dynamic_return` / `narrowing_facts`
 
 > **Critical — these hooks do NOT make a method "defined", so they do
 > NOT suppress `call.undefined-method`.** Method *existence* and call
@@ -197,11 +197,15 @@ end
 # Post-return NARROWING FACTS, gated on the call's method name.
 # Return an Array of facts (or nil). Used for assertion / predicate
 # narrowing (`assert_kind_of(Foo, x)` ⇒ x is Foo afterwards).
-type_specifier methods: [:assert_kind_of] do |call_node, scope|
+narrowing_facts methods: [:assert_kind_of] do |call_node, scope|
   # ... build and return the post-return facts ...
 end
 ```
 
+> **`narrowing_facts` was renamed from `type_specifier` in ADR-80.**
+> `type_specifier` remains as a deprecating alias, removed in 0.3.0 — use
+> `narrowing_facts` in new plugins.
+
 Build return types with `Rigor::Type::Combinator`:
 
 ```ruby
@@ -240,7 +244,7 @@ If the DSL introduces methods or classes that Rigor cannot see (a
 Rigor RBS declaring them so *core* inference — not just your plugin —
 treats them as **defined**. This is what removes the
 `call.undefined-method` diagnostics on those methods; nothing else
-(not a `node_rule`, not `dynamic_return` / `type_specifier`) makes a
+(not a `node_rule`, not `dynamic_return` / `narrowing_facts`) makes a
 method exist in Rigor's view.
 
 Two ways to wire the RBS, depending on how the plugin is packaged:
@@ -288,6 +292,6 @@ They compose — many plugins ship both.
 
 A plugin whose `node_rule`(s) recognise the DSL and emit diagnostics
 with correct severities and rule ids — optionally a `dynamic_return` /
-`type_specifier` and a `sig/` bundle. Verify by eye with `rigor check`;
+`narrowing_facts` and a `sig/` bundle. Verify by eye with `rigor check`;
 lock it down with tests in Phase 3
 ([`03-test-and-ship.md`](03-test-and-ship.md)).

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.6
 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
@@ -440,6 +460,7 @@ files:
 - lib/rigor/cli/annotate_command.rb
 - lib/rigor/cli/baseline_command.rb
 - lib/rigor/cli/check_command.rb
+- lib/rigor/cli/check_runner_factory.rb
 - lib/rigor/cli/ci_detector.rb
 - lib/rigor/cli/command.rb
 - lib/rigor/cli/coverage_command.rb
@@ -450,6 +471,7 @@ files:
 - lib/rigor/cli/diagnostic_formats.rb
 - lib/rigor/cli/diff_command.rb
 - lib/rigor/cli/docs_command.rb
+- lib/rigor/cli/doctor_command.rb
 - lib/rigor/cli/explain_command.rb
 - lib/rigor/cli/fused_protection_renderer.rb
 - lib/rigor/cli/fused_protection_report.rb
@@ -478,6 +500,7 @@ files:
 - lib/rigor/cli/type_scan_command.rb
 - lib/rigor/cli/type_scan_renderer.rb
 - lib/rigor/cli/type_scan_report.rb
+- lib/rigor/cli/upgrade_command.rb
 - lib/rigor/config_audit.rb
 - lib/rigor/configuration.rb
 - lib/rigor/configuration/dependencies.rb
@@ -527,6 +550,7 @@ files:
 - lib/rigor/inference/closure_escape_analyzer.rb
 - lib/rigor/inference/coverage_scanner.rb
 - lib/rigor/inference/def_return_typer.rb
+- lib/rigor/inference/dynamic_origin.rb
 - lib/rigor/inference/expression_typer.rb
 - lib/rigor/inference/fallback.rb
 - lib/rigor/inference/fallback_tracer.rb
@@ -934,7 +958,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: []