rigortype 0.1.15 → 0.1.16

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/analyzer.rb

@@ -31,45 +31,40 @@ module Rigor
       module Analyzer
         ENTRY_METHODS = %i[authorize policy policy_scope].freeze
 
-        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+        # One policy violation: the kebab-case `rule`, `severity`, and
+        # human-readable `message`. Carries no path/location — the caller
+        # (the `node_rule` block) positions it via `Plugin::Base#diagnostic`.
+        Violation = Struct.new(:rule, :severity, :message, keyword_init: true)
 
         module_function
 
-        # @param path [String]
-        # @param root [Prism::Node]
+        # The policy violations for a single call node (0..2 of them), or
+        # `[]` when the node is not a Pundit entry call or its record type
+        # is not statically determinable. ADR-37: the engine owns the
+        # walk, so this is per-node logic.
+        #
+        # @param call_node [Prism::Node]
         # @param policy_index [PolicyIndex]
-        # @param scope [Rigor::Inference::Scope, nil]
-        # @return [Array<Diagnostic>]
-        def diagnose(path:, root:, policy_index:, scope:)
-          diagnostics = []
-          walk(root) do |call_node|
-            record_node = call_node.arguments&.arguments&.first
-            next if record_node.nil?
+        # @param scope [Rigor::Scope, nil]
+        # @return [Array<Violation>]
+        def violations_for(call_node:, policy_index:, scope:)
+          return [] unless call_node.is_a?(Prism::CallNode) && entry_call?(call_node)
 
-            policy_class_name = derive_policy_class_name(record_node, scope)
-            next if policy_class_name.nil?
+          record_node = call_node.arguments&.arguments&.first
+          return [] if record_node.nil?
 
-            policy_entry = policy_index.find(policy_class_name)
-            if policy_entry.nil?
-              diagnostics << unknown_policy_class_diagnostic(path, call_node, policy_class_name, policy_index)
-              next
-            end
+          policy_class_name = derive_policy_class_name(record_node, scope)
+          return [] if policy_class_name.nil?
 
-            diagnostics << policy_call_info(path, call_node, policy_class_name)
+          policy_entry = policy_index.find(policy_class_name)
+          return [unknown_policy_class_violation(call_node, policy_class_name, policy_index)] if policy_entry.nil?
 
-            next unless call_node.name == :authorize
-
-            action_diag = action_check(path, call_node, policy_entry)
-            diagnostics << action_diag if action_diag
+          violations = [policy_call_violation(call_node, policy_class_name)]
+          if call_node.name == :authorize
+            action = action_violation(call_node, policy_entry)
+            violations << action if action
           end
-          diagnostics
-        end
-
-        def walk(node, &)
-          return unless node.is_a?(Prism::Node)
-
-          yield node if node.is_a?(Prism::CallNode) && entry_call?(node)
-          node.compact_child_nodes.each { |child| walk(child, &) }
+          violations
         end
 
         def entry_call?(node)
@@ -105,26 +100,18 @@ module Rigor
           nil
         end
 
-        def policy_call_info(path, call_node, policy_class_name)
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+        def policy_call_violation(call_node, policy_class_name)
+          Violation.new(
             severity: :info,
             rule: "policy-call",
             message: "`#{call_node.name}(...)` resolves to `#{policy_class_name}`"
           )
         end
 
-        def unknown_policy_class_diagnostic(path, call_node, policy_class_name, policy_index)
-          location = call_node.location
+        def unknown_policy_class_violation(call_node, policy_class_name, policy_index)
           suggestions = DidYouMean::SpellChecker.new(dictionary: policy_index.names).correct(policy_class_name)
           suggestion_part = suggestions.empty? ? "" : " (did you mean `#{suggestions.first}`?)"
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :error,
             rule: "unknown-policy-class",
             message: "no policy class `#{policy_class_name}` for `#{call_node.name}` call#{suggestion_part}"
@@ -136,7 +123,7 @@ module Rigor
         # (the runtime infers it from the controller — out
         # of scope here) or when the second argument isn't
         # a literal symbol / string.
-        def action_check(path, call_node, policy_entry)
+        def action_violation(call_node, policy_entry)
           args = call_node.arguments&.arguments || []
           return nil if args.size < 2
 
@@ -147,14 +134,10 @@ module Rigor
           predicate = policy_entry.normalize(action_name)
           return nil if policy_entry.includes_method?(predicate)
 
-          location = call_node.location
           dictionary = policy_entry.predicate_methods.map(&:to_s)
           suggestions = DidYouMean::SpellChecker.new(dictionary: dictionary).correct(predicate.to_s)
           suggestion_part = suggestions.empty? ? "" : " (did you mean `:#{suggestions.first.delete_suffix('?')}`?)"
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :error,
             rule: "unknown-policy-method",
             message: "`#{policy_entry.policy_class_name}##{predicate}` is not defined " \

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

@@ -61,14 +61,11 @@ module Rigor
         version: "0.1.0",
         description: "Validates Pundit policy / authorize calls.",
         config_schema: {
-          "policy_search_paths" => :array,
-          "policy_base_classes" => :array
+          "policy_search_paths" => { kind: :array, default: ["app/policies"] },
+          "policy_base_classes" => { kind: :array, default: %w[ApplicationPolicy] }
         }
       )
 
-      DEFAULT_POLICY_SEARCH_PATHS = ["app/policies"].freeze
-      DEFAULT_POLICY_BASE_CLASSES = %w[ApplicationPolicy].freeze
-
       producer :policy_index do |_params|
         PolicyDiscoverer.new(
           io_boundary: io_boundary,
@@ -78,23 +75,30 @@ module Rigor
       end
 
       def init(_services)
-        @policy_search_paths = Array(config.fetch("policy_search_paths", DEFAULT_POLICY_SEARCH_PATHS)).map(&:to_s)
-        @policy_base_classes = Array(config.fetch("policy_base_classes", DEFAULT_POLICY_BASE_CLASSES)).map(&:to_s)
+        @policy_search_paths = Array(config.fetch("policy_search_paths")).map(&:to_s)
+        @policy_base_classes = Array(config.fetch("policy_base_classes")).map(&:to_s)
         @policy_index = nil
         @load_error = nil
       end
 
-      def diagnostics_for_file(path:, scope:, root:)
+      # File-level only: the load-error emission. The per-call policy
+      # validation runs over the engine-owned walk via the node_rule
+      # below (ADR-37). The index is lazily loaded + memoised by
+      # policy_index_or_nil, so both surfaces share one load.
+      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = policy_index_or_nil
         return [load_error_diagnostic(path)] if index.nil? && @load_error
-        return [] if index.nil? || index.empty?
 
-        Analyzer.diagnose(
-          path: path,
-          root: root,
-          policy_index: index,
-          scope: scope
-        ).map { |diag| build_diagnostic(diag) }
+        []
+      end
+
+      node_rule Prism::CallNode do |node, scope, path|
+        index = policy_index_or_nil
+        next [] if index.nil? || index.empty?
+
+        Analyzer.violations_for(call_node: node, policy_index: index, scope: scope).map do |violation|
+          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
+        end
       end
 
       private
@@ -102,7 +106,8 @@ module Rigor
       def policy_index_or_nil
         return @policy_index if @policy_index
 
-        @policy_index = cache_for(:policy_index, params: {}).call
+        descriptor = glob_descriptor(@policy_search_paths, "**/*.rb")
+        @policy_index = cache_for(:policy_index, params: {}, descriptor: descriptor).call
       rescue StandardError => e
         @load_error = "rigor-pundit: failed to discover policies: #{e.class}: #{e.message}"
         nil
@@ -116,13 +121,6 @@ module Rigor
           rule: "load-error"
         )
       end
-
-      def build_diagnostic(diag)
-        Rigor::Analysis::Diagnostic.new(
-          path: diag.path, line: diag.line, column: diag.column,
-          message: diag.message, severity: diag.severity, rule: diag.rule
-        )
-      end
     end
 
     Rigor::Plugin.register(Pundit)

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

@@ -75,7 +75,10 @@ module Rigor
           activerecord.errors.models.
         ].freeze
 
-        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+        # One translation-call observation. Carries no path/location —
+        # the caller (the `node_rule` block) positions it via
+        # `Plugin::Base#diagnostic`.
+        Violation = Struct.new(:rule, :severity, :message, keyword_init: true)
 
         module_function
 
@@ -89,60 +92,48 @@ module Rigor
         # @param locale_index [LocaleIndex]
         # @param configured_locales [Array<String>]
         # @return [Array<Diagnostic>]
-        def diagnose(path:, root:, locale_index:, configured_locales:)
-          controller_scope = controller_scope_from_path(path)
-          diagnostics = []
-          walk(root) do |call_node, action|
-            raw_key = literal_key_for(call_node)
-            next if raw_key.nil?
-
-            literal_key = expand_key(raw_key, controller_scope: controller_scope, action: action)
-            next if literal_key.nil?
-
-            options = options_hash(call_node)
-            entry = locale_index.find(literal_key)
-            if entry.nil?
-              # CLDR pluralization namespace: the parent key isn't
-              # a leaf, but at least one `.one` / `.other` / etc.
-              # child exists. `t('accounts.posts', count: n)`
-              # resolves through that branch — not a missing key.
-              # Accept silently; downstream interpolation checks
-              # don't apply (no single entry to read placeholders
-              # from).
-              next if locale_index.pluralization_namespace?(literal_key)
-
-              # Rails / rails-i18n ship `date.order`, `time.am`,
-              # `support.array.words_connector`, etc. in every
-              # locale at runtime even when the project's own
-              # locale files don't repeat them. Accept silently
-              # — no leaf entry → no downstream interpolation
-              # check to run.
-              next if rails_shipped_key?(literal_key)
-
-              diagnostics << unknown_key_diagnostic(path, call_node, literal_key, locale_index)
-              next
-            end
-
-            diagnostics << translation_call_info(path, call_node, literal_key, entry)
-            missing_in_locales = locale_index.missing_locales_for(literal_key, configured_locales: configured_locales)
-            diagnostics << missing_locale_diagnostic(path, call_node, literal_key, missing_in_locales) \
-              if !options[:has_default] && !missing_in_locales.empty?
-
-            interpolation_diags = interpolation_diagnostics(path, call_node, literal_key, entry, options)
-            diagnostics.concat(interpolation_diags)
+        # The translation violations for a single call node, or `[]`
+        # when it is not a recognised `t` / `translate` call with a
+        # literal key. ADR-37: the engine owns the walk; `action` (the
+        # enclosing method, for lazy `t('.key')` expansion) comes from
+        # the node-rule `NodeContext`, and `controller_scope` from the
+        # file path.
+        #
+        # @param call_node [Prism::Node]
+        # @param locale_index [LocaleIndex]
+        # @param configured_locales [Array<String>]
+        # @param controller_scope [String, nil]
+        # @param action [String, nil]
+        # @return [Array<Violation>]
+        def violations_for(call_node:, locale_index:, configured_locales:, controller_scope:, action:)
+          return [] unless call_node.is_a?(Prism::CallNode) && translate_call_candidate?(call_node)
+
+          raw_key = literal_key_for(call_node)
+          return [] if raw_key.nil?
+
+          literal_key = expand_key(raw_key, controller_scope: controller_scope, action: action)
+          return [] if literal_key.nil?
+
+          options = options_hash(call_node)
+          entry = locale_index.find(literal_key)
+          if entry.nil?
+            # CLDR pluralization namespace: `t('accounts.posts', count: n)`
+            # resolves through a `.one` / `.other` child — not missing.
+            return [] if locale_index.pluralization_namespace?(literal_key)
+            # Rails / rails-i18n ship `date.order`, `time.am`, etc. in
+            # every locale at runtime even when project files omit them.
+            return [] if rails_shipped_key?(literal_key)
+
+            return [unknown_key_violation(literal_key, locale_index)]
           end
-          diagnostics
-        end
 
-        # Walks the AST yielding `[call_node, action]` pairs where
-        # `action` is the name of the innermost enclosing `def`
-        # method (or `nil` when the call is at the top level).
-        def walk(node, action: nil, &)
-          return unless node.is_a?(Prism::Node)
-
-          current_action = node.is_a?(Prism::DefNode) ? node.name.to_s : action
-          yield node, current_action if node.is_a?(Prism::CallNode) && translate_call_candidate?(node)
-          node.compact_child_nodes.each { |child| walk(child, action: current_action, &) }
+          violations = [translation_call_info(literal_key, entry)]
+          missing_in_locales = locale_index.missing_locales_for(literal_key, configured_locales: configured_locales)
+          if !options[:has_default] && !missing_in_locales.empty?
+            violations << missing_locale_violation(literal_key, missing_in_locales)
+          end
+          violations.concat(interpolation_violations(literal_key, entry, options))
+          violations
         end
 
         # Derives the Rails controller scope from the file path,
@@ -247,60 +238,44 @@ module Rigor
           end
         end
 
-        def translation_call_info(path, call_node, literal_key, entry)
-          location = call_node.location
+        def translation_call_info(literal_key, entry)
           locales_text = entry.locales.sort.join(", ")
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :info,
             rule: "translation-call",
             message: "`t('#{literal_key}')` resolves in #{locales_text}"
           )
         end
 
-        def unknown_key_diagnostic(path, call_node, literal_key, locale_index)
-          location = call_node.location
+        def unknown_key_violation(literal_key, locale_index)
           suggestions = DidYouMean::SpellChecker.new(dictionary: locale_index.keys).correct(literal_key)
           suggestion_part = suggestions.empty? ? "" : " (did you mean `#{suggestions.first}`?)"
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :error,
             rule: "unknown-key",
             message: "missing translation key `#{literal_key}` in any locale#{suggestion_part}"
           )
         end
 
-        def missing_locale_diagnostic(path, call_node, literal_key, missing_locales)
-          location = call_node.location
+        def missing_locale_violation(literal_key, missing_locales)
           locales_text = missing_locales.to_a.sort.join(", ")
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :warning,
             rule: "missing-locale",
             message: "`t('#{literal_key}')` is missing from locale(s) #{locales_text}"
           )
         end
 
-        def interpolation_diagnostics(path, call_node, literal_key, entry, options)
+        def interpolation_violations(literal_key, entry, options)
           required = entry.all_placeholders
           all_provided = options[:all_keys].to_set(&:to_s)
           non_reserved_provided = options[:non_reserved].to_set(&:to_s)
           missing = required - all_provided
           extra = non_reserved_provided - required
-          location = call_node.location
 
-          [].tap do |diags|
+          [].tap do |violations|
             unless missing.empty?
-              diags << Diagnostic.new(
-                path: path,
-                line: location.start_line,
-                column: location.start_column + 1,
+              violations << Violation.new(
                 severity: :error,
                 rule: "wrong-interpolation",
                 message: "`t('#{literal_key}')` expects interpolation #{format_keys(missing)}, " \
@@ -309,10 +284,7 @@ module Rigor
             end
 
             unless extra.empty?
-              diags << Diagnostic.new(
-                path: path,
-                line: location.start_line,
-                column: location.start_column + 1,
+              violations << Violation.new(
                 severity: :warning,
                 rule: "extra-interpolation",
                 message: "`t('#{literal_key}')` does not use interpolation #{format_keys(extra)} " \

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

@@ -67,14 +67,11 @@ module Rigor
         version: "0.2.0",
         description: "Validates I18n `t(key)` calls against `config/locales/*.yml`.",
         config_schema: {
-          "locale_search_paths" => :array,
-          "configured_locales" => :array
+          "locale_search_paths" => { kind: :array, default: ["config/locales"] },
+          "configured_locales" => { kind: :array, default: ["en"] }
         }
       )
 
-      DEFAULT_LOCALE_SEARCH_PATHS = ["config/locales"].freeze
-      DEFAULT_CONFIGURED_LOCALES = ["en"].freeze
-
       producer :locale_index do |_params|
         loader = LocaleLoader.new(
           io_boundary: io_boundary,
@@ -86,32 +83,42 @@ module Rigor
       end
 
       def init(_services)
-        @locale_search_paths = Array(config.fetch("locale_search_paths", DEFAULT_LOCALE_SEARCH_PATHS)).map(&:to_s)
-        @configured_locales = Array(config.fetch("configured_locales", DEFAULT_CONFIGURED_LOCALES)).map(&:to_s)
+        @locale_search_paths = Array(config.fetch("locale_search_paths")).map(&:to_s)
+        @configured_locales = Array(config.fetch("configured_locales")).map(&:to_s)
         @locale_index = nil
         @load_errors = []
         @load_errors_emitted = false
         @runtime_error = nil
       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 locale_index_or_nil.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = locale_index_or_nil
         diagnostics = []
         diagnostics.concat(consume_load_error_diagnostics(path)) unless @load_errors.empty?
-        return diagnostics + [runtime_error_diagnostic(path)] if index.nil? && @runtime_error
-        return diagnostics if index.nil? || index.empty?
-
-        diagnostics.concat(
-          Analyzer.diagnose(
-            path: path,
-            root: root,
-            locale_index: index,
-            configured_locales: @configured_locales
-          ).map { |diag| build_diagnostic(diag) }
-        )
+        diagnostics << runtime_error_diagnostic(path) if index.nil? && @runtime_error
         diagnostics
       end
 
+      # The lazy-key (`t('.key')`) expansion needs the enclosing method
+      # (the controller action), supplied by the node-rule NodeContext;
+      # the controller scope comes from the file path.
+      node_rule Prism::CallNode do |node, _scope, path, _fc, context|
+        index = locale_index_or_nil
+        next [] if index.nil? || index.empty?
+
+        Analyzer.violations_for(
+          call_node: node, locale_index: index, configured_locales: @configured_locales,
+          controller_scope: Analyzer.controller_scope_from_path(path),
+          action: context.enclosing_def&.name
+        ).map do |violation|
+          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
+        end
+      end
+
       private
 
       def locale_index_or_nil
@@ -161,13 +168,6 @@ module Rigor
           rule: "load-error"
         )
       end
-
-      def build_diagnostic(diag)
-        Rigor::Analysis::Diagnostic.new(
-          path: diag.path, line: diag.line, column: diag.column,
-          message: diag.message, severity: diag.severity, rule: diag.rule
-        )
-      end
     end
 
     Rigor::Plugin.register(RailsI18n)