rigortype 0.1.14 → 0.1.16

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

@@ -62,17 +62,14 @@ module Rigor
         version: "0.1.0",
         description: "Validates ActionCable broadcast call shape against discovered channels.",
         config_schema: {
-          "channel_search_paths" => :array,
-          "channel_base_classes" => :array
+          "channel_search_paths" => { kind: :array, default: ["app/channels"] },
+          "channel_base_classes" => {
+            kind: :array,
+            default: ["ApplicationCable::Channel", "ActionCable::Channel::Base"]
+          }
         }
       )
 
-      DEFAULT_CHANNEL_SEARCH_PATHS = ["app/channels"].freeze
-      DEFAULT_CHANNEL_BASE_CLASSES = [
-        "ApplicationCable::Channel",
-        "ActionCable::Channel::Base"
-      ].freeze
-
       producer :channel_index do |_params|
         ChannelDiscoverer.new(
           io_boundary: io_boundary,
@@ -82,22 +79,30 @@ module Rigor
       end
 
       def init(_services)
-        @channel_search_paths = Array(
-          config.fetch("channel_search_paths", DEFAULT_CHANNEL_SEARCH_PATHS)
-        ).map(&:to_s)
-        @channel_base_classes = Array(
-          config.fetch("channel_base_classes", DEFAULT_CHANNEL_BASE_CLASSES)
-        ).map(&:to_s)
+        @channel_search_paths = Array(config.fetch("channel_search_paths")).map(&:to_s)
+        @channel_base_classes = Array(config.fetch("channel_base_classes")).map(&:to_s)
         @channel_index = nil
         @load_error = nil
       end
 
+      # File-level only: the load-error emission. Per-call broadcast
+      # validation runs over the engine-owned walk via the node_rule
+      # below (ADR-37). The channel index is lazily loaded + memoised by
+      # channel_index_or_nil, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = channel_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, channel_index: index).map { |diag| build_diagnostic(diag) }
+        []
+      end
+
+      node_rule Prism::CallNode do |node, _scope, path|
+        index = channel_index_or_nil
+        next [] if index.nil? || index.empty?
+
+        Analyzer.violations_for(call_node: node, channel_index: index).map do |violation|
+          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
+        end
       end
 
       private
@@ -128,13 +133,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(Actioncable)

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

@@ -45,53 +45,44 @@ module Rigor
           method instance_method methods
         ].freeze
 
-        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+        # One mailer-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
 
-        # @param path [String]
-        # @param root [Prism::Node]
+        # The mailer-call violations for a single call node (0..2), or
+        # `[]` when it is not a `<Mailer>.action(...)` call on a known
+        # mailer. ADR-37: the engine owns the walk.
+        #
+        # @param call_node [Prism::Node]
         # @param mailer_index [MailerIndex]
-        # @return [Array<Diagnostic>]
-        def diagnose(path:, root:, mailer_index:)
-          diagnostics = []
-          walk(root) do |call_node|
-            class_name = mailer_class_for_call(call_node)
-            next if class_name.nil?
-            next if RESERVED_CLASS_METHODS.include?(call_node.name)
-
-            class_entry = mailer_index.find(class_name) || mailer_index.find("::#{class_name}")
-            next if class_entry.nil?
-
-            action_entry = class_entry.find_action(call_node.name)
-            if action_entry.nil?
-              # Skip `unknown-action` when the mailer's include
-              # set has any unresolved module — the unresolved
-              # module may legitimately define the action
-              # (gem-shipped concern, dynamically loaded
-              # mailer extension). Mirrors the same predicate
-              # `rigor-actionpack` uses for unknown-filter-method.
-              next if class_entry.unresolved_includes?
-
-              diagnostics << unknown_action_diagnostic(path, call_node, class_entry)
-              next
-            end
-
-            diagnostics << action_call_info(path, call_node, class_entry, action_entry)
-            arity_diag = arity_check(path, call_node, class_entry, action_entry)
-            diagnostics << arity_diag if arity_diag
-          end
-          diagnostics
-        end
+        # @return [Array<Violation>]
+        def violations_for(call_node:, mailer_index:)
+          return [] unless call_node.is_a?(Prism::CallNode) && action_call_candidate?(call_node)
+
+          class_name = mailer_class_for_call(call_node)
+          return [] if class_name.nil?
+          return [] if RESERVED_CLASS_METHODS.include?(call_node.name)
 
-        # Walks the tree yielding every CallNode whose receiver
-        # resolves (directly or through `.with(...)`) to a
-        # constant.
-        def walk(node, &)
-          return unless node.is_a?(Prism::Node)
+          class_entry = mailer_index.find(class_name) || mailer_index.find("::#{class_name}")
+          return [] if class_entry.nil?
+
+          action_entry = class_entry.find_action(call_node.name)
+          if action_entry.nil?
+            # Skip `unknown-action` when the mailer's include set has any
+            # unresolved module — it may legitimately define the action
+            # (gem-shipped concern, dynamically loaded extension).
+            return [] if class_entry.unresolved_includes?
+
+            return [unknown_action_violation(call_node, class_entry)]
+          end
 
-          yield node if node.is_a?(Prism::CallNode) && action_call_candidate?(node)
-          node.compact_child_nodes.each { |child| walk(child, &) }
+          violations = [action_call_info(call_node, class_entry, action_entry)]
+          arity = arity_violation(call_node, class_entry, action_entry)
+          violations << arity if arity
+          violations
         end
 
         def action_call_candidate?(node)
@@ -120,12 +111,8 @@ module Rigor
           end
         end
 
-        def action_call_info(path, call_node, class_entry, action_entry)
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+        def action_call_info(_call_node, class_entry, action_entry)
+          Violation.new(
             severity: :info,
             rule: "mailer-call",
             message: "`#{class_entry.class_name}.#{action_entry.method_name}` " \
@@ -133,7 +120,7 @@ module Rigor
           )
         end
 
-        def arity_check(path, call_node, class_entry, action_entry)
+        def arity_violation(call_node, class_entry, action_entry)
           args = call_node.arguments&.arguments || []
           actual = args.size
           return nil if action_entry.accepts?(actual)
@@ -147,11 +134,7 @@ module Rigor
           # carrying calls don't surface as wrong-arity.
           return nil if args.last.is_a?(Prism::KeywordHashNode) && action_entry.accepts?(actual - 1)
 
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :error,
             rule: "wrong-arity",
             message: "`#{class_entry.class_name}.#{action_entry.method_name}` " \
@@ -159,14 +142,10 @@ module Rigor
           )
         end
 
-        def unknown_action_diagnostic(path, call_node, class_entry)
-          location = call_node.location
+        def unknown_action_violation(call_node, class_entry)
           known = class_entry.actions.keys.sort.join(", ")
           known_part = known.empty? ? "no actions defined" : "known actions: #{known}"
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :error,
             rule: "unknown-action",
             message: "`#{class_entry.class_name}.#{call_node.name}` is not a defined " \

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_discoverer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "rigor/source/literals"
 
 require_relative "mailer_index"
 
@@ -264,7 +265,7 @@ module Rigor
             next unless node.is_a?(Prism::CallNode) && node.receiver.nil?
 
             args = (node.arguments&.arguments || []).filter_map do |arg|
-              arg.is_a?(Prism::SymbolNode) ? arg.unescaped.to_sym : nil
+              Rigor::Source::Literals.symbol(arg)
             end
             next if args.empty?
 
@@ -371,7 +372,11 @@ module Rigor
         # denied) are swallowed.
         def view_exists?(class_name, action_name)
           views_root_absolute = File.expand_path(@views_root)
-          underscore_path = underscore(class_name.delete_prefix("::"))
+          # ADR-39: the real ActiveSupport::Inflector resolves the mailer's
+          # view directory (`Foo::BarMailer` → `foo/bar_mailer`), so a
+          # divergence from Rails' real underscore can't point the
+          # missing-view check at the wrong directory.
+          underscore_path = Rigor::Plugin::Inflector.underscore(class_name.delete_prefix("::"))
           mailer_dir = File.join(views_root_absolute, underscore_path)
 
           VIEW_FORMATS.any? do |format|
@@ -381,17 +386,6 @@ module Rigor
             end
           end
         end
-
-        # Convert `Foo::BarMailer` → `foo/bar_mailer`. Mirrors
-        # ActiveSupport's String#underscore for ASCII-only
-        # constant names; we don't try to be inflector-perfect
-        # here.
-        def underscore(name)
-          name.gsub("::", "/")
-              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-              .downcase
-        end
       end
     end
   end

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

@@ -59,16 +59,12 @@ module Rigor
         version: "0.4.0",
         description: "Validates ActionMailer call shape and view template existence.",
         config_schema: {
-          "mailer_search_paths" => :array,
-          "mailer_base_classes" => :array,
-          "views_root" => :string
+          "mailer_search_paths" => { kind: :array, default: ["app/mailers"] },
+          "mailer_base_classes" => { kind: :array, default: %w[ApplicationMailer ActionMailer::Base] },
+          "views_root" => { kind: :string, default: "app/views" }
         }
       )
 
-      DEFAULT_MAILER_SEARCH_PATHS = ["app/mailers"].freeze
-      DEFAULT_MAILER_BASE_CLASSES = %w[ApplicationMailer ActionMailer::Base].freeze
-      DEFAULT_VIEWS_ROOT = "app/views"
-
       producer :mailer_index do |_params|
         MailerDiscoverer.new(
           io_boundary: io_boundary,
@@ -79,22 +75,33 @@ module Rigor
       end
 
       def init(_services)
-        @mailer_search_paths = Array(config.fetch("mailer_search_paths", DEFAULT_MAILER_SEARCH_PATHS)).map(&:to_s)
-        @mailer_base_classes = Array(config.fetch("mailer_base_classes", DEFAULT_MAILER_BASE_CLASSES)).map(&:to_s)
-        @views_root = config.fetch("views_root", DEFAULT_VIEWS_ROOT).to_s
+        @mailer_search_paths = Array(config.fetch("mailer_search_paths")).map(&:to_s)
+        @mailer_base_classes = Array(config.fetch("mailer_base_classes")).map(&:to_s)
+        @views_root = config.fetch("views_root").to_s
         @mailer_index = nil
         @load_error = nil
       end
 
+      # File-level: load-error + the missing-view check (anchored on the
+      # mailer's own source file, so it is genuinely per-file, not
+      # per-call). The per-call mailer validation (action existence /
+      # arity) runs over the engine-owned walk via the node_rule below
+      # (ADR-37). The mailer index is lazily loaded + memoised, shared.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = mailer_index_or_nil
         return [load_error_diagnostic(path)] if index.nil? && @load_error
         return [] if index.nil? || index.empty?
 
-        diagnostics = []
-        diagnostics.concat(call_site_diagnostics(path, root, index))
-        diagnostics.concat(missing_view_diagnostics(path, index))
-        diagnostics
+        missing_view_diagnostics(path, index)
+      end
+
+      node_rule Prism::CallNode do |node, _scope, path|
+        index = mailer_index_or_nil
+        next [] if index.nil? || index.empty?
+
+        Analyzer.violations_for(call_node: node, mailer_index: index).map do |violation|
+          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
+        end
       end
 
       private
@@ -121,10 +128,6 @@ module Rigor
         nil
       end
 
-      def call_site_diagnostics(path, root, index)
-        Analyzer.diagnose(path: path, root: root, mailer_index: index).map { |diag| build_diagnostic(diag) }
-      end
-
       # Anchors `missing-view` diagnostics on the mailer file
       # itself: when the file currently being analysed is the
       # mailer's source file, emit one diagnostic per missing
@@ -143,7 +146,7 @@ module Rigor
             severity: :warning,
             rule: "missing-view",
             message: "`#{class_entry.class_name}##{action_name}` has no view template " \
-                     "under `#{@views_root}/#{underscore(class_entry.class_name.delete_prefix('::'))}/`"
+                     "under `#{@views_root}/#{Rigor::Plugin::Inflector.underscore(class_entry.class_name.delete_prefix('::'))}/`"
           )
         end
       end
@@ -154,13 +157,6 @@ module Rigor
         File.expand_path(path)
       end
 
-      def underscore(name)
-        name.gsub("::", "/")
-            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-            .downcase
-      end
-
       def load_error_diagnostic(path)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
@@ -169,13 +165,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(Actionmailer)