rigortype 0.1.10 → 0.1.12

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers/analyzer.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class ShouldaMatchers < Rigor::Plugin::Base
+      # Walks every `RSpec.describe <ModelConst> do ... end` /
+      # `describe <ModelConst> do ... end` block and validates
+      # the shoulda-matchers calls inside its body (any depth
+      # of nested `describe` / `context`) against the
+      # `:model_index` published by `rigor-activerecord`.
+      #
+      # The "anchor" for cross-checking is the OUTERMOST
+      # describe block whose argument is a constant — that
+      # constant names the model being specced. Nested
+      # `describe ".some_method"` (String / Symbol args) does
+      # NOT change the anchor.
+      #
+      # ## Recognised matcher calls (v0.1.0)
+      #
+      # ### Column / db matchers
+      #
+      #   validate_presence_of(:col)
+      #   validate_uniqueness_of(:col)
+      #   validate_length_of(:col)
+      #   validate_numericality_of(:col)
+      #   validate_acceptance_of(:col)
+      #   validate_inclusion_of(:col)
+      #   validate_exclusion_of(:col)
+      #   validate_absence_of(:col)
+      #   validate_format_of(:col)
+      #   validate_confirmation_of(:col)
+      #   allow_value(...).for(:col)
+      #   have_db_column(:col)
+      #   have_db_index(:col)
+      #
+      # All look up `:col` against the model's columns
+      # (`Entry#column?`). Unknown columns fire
+      # `shoulda-matchers.unknown-column`.
+      #
+      # ### Association matchers
+      #
+      #   belong_to(:assoc)           ← expects :singular
+      #   have_one(:assoc)            ← expects :singular
+      #   have_many(:assoc)           ← expects :collection
+      #   have_and_belong_to_many(:assoc) ← expects :collection
+      #
+      # Unknown associations fire
+      # `shoulda-matchers.unknown-association`. Known
+      # associations with mismatched kind (`should belong_to(:posts)`
+      # where `:posts` is `has_many`) fire
+      # `shoulda-matchers.association-kind-mismatch`.
+      module Analyzer
+        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+
+        # `(matcher_name) => (:column | :association_singular | :association_collection)`
+        # — the validation lane each matcher routes to.
+        MATCHER_TABLE = {
+          # Column matchers — validate the named column exists on the model.
+          validate_presence_of: :column,
+          validate_uniqueness_of: :column,
+          validate_length_of: :column,
+          validate_numericality_of: :column,
+          validate_acceptance_of: :column,
+          validate_inclusion_of: :column,
+          validate_exclusion_of: :column,
+          validate_absence_of: :column,
+          validate_format_of: :column,
+          validate_confirmation_of: :column,
+          have_db_column: :column,
+          have_db_index: :column,
+          # Association matchers — validate the association
+          # exists AND its kind matches the matcher.
+          belong_to: :association_singular,
+          have_one: :association_singular,
+          have_many: :association_collection,
+          have_and_belong_to_many: :association_collection
+        }.freeze
+
+        module_function
+
+        # @param path [String]
+        # @param root [Prism::Node]
+        # @param model_index [Object, nil] the `:model_index`
+        #   fact value. When nil the analyzer falls silent.
+        # @return [Array<Diagnostic>]
+        def diagnose(path:, root:, model_index:)
+          return [] if model_index.nil?
+
+          diagnostics = []
+          walk_describe(root, anchor_model: nil) do |matcher_call, anchor|
+            entry = model_index.find(anchor)
+            next if entry.nil?
+
+            diagnostic = diagnostic_for(matcher_call, path, anchor, entry)
+            diagnostics << diagnostic if diagnostic
+          end
+          diagnostics
+        end
+
+        # Walks for `RSpec.describe(Const)` / `describe(Const)`
+        # blocks (the Const is the model anchor) and yields
+        # every matcher call found in their body.
+        #
+        # The anchor stays the OUTERMOST describe-with-const
+        # — nested describes / contexts inherit it without
+        # overriding (a nested `describe ".active"` is not a
+        # model constant). When a nested describe DOES name a
+        # different model, the nested anchor wins inside that
+        # subtree (rare; we still honour it).
+        def walk_describe(node, anchor_model:, &)
+          return unless node.is_a?(Prism::Node)
+
+          if describe_with_constant?(node)
+            inner_anchor = describe_const_name(node) || anchor_model
+            collect_matchers(node.block.body, inner_anchor, &) if node.block&.body
+            return
+          end
+
+          node.compact_child_nodes.each do |child|
+            walk_describe(child, anchor_model: anchor_model, &)
+          end
+        end
+
+        # Walks the body of a describe block looking for:
+        #   (a) matcher calls — `should MATCHER` or
+        #       `expect(...).to MATCHER` chains; we yield the
+        #       inner MATCHER call.
+        #   (b) nested describe / context blocks — we recurse
+        #       so deeper matchers are reachable.
+        def collect_matchers(body, anchor, &)
+          return unless body.is_a?(Prism::Node)
+          return if anchor.nil?
+
+          if matcher_invocation?(body)
+            yield body, anchor
+            return
+          end
+
+          if describe_with_constant?(body)
+            inner_anchor = describe_const_name(body) || anchor
+            collect_matchers(body.block.body, inner_anchor, &) if body.block&.body
+            return
+          end
+
+          body.compact_child_nodes.each do |child|
+            collect_matchers(child, anchor, &)
+          end
+        end
+
+        # A direct matcher invocation is a `CallNode` whose
+        # `name` is in `MATCHER_TABLE` and whose first argument
+        # is a `SymbolNode`. The chain shape (`should`,
+        # `expect(...).to`, `is_expected.to`) is irrelevant —
+        # we always recurse to the inner matcher, so a
+        # diagnostic fires on the matcher regardless of the
+        # surrounding chain.
+        def matcher_invocation?(node)
+          node.is_a?(Prism::CallNode) && MATCHER_TABLE.key?(node.name) && symbol_first_arg?(node)
+        end
+
+        def symbol_first_arg?(call_node)
+          args = call_node.arguments&.arguments || []
+          !args.empty? && args.first.is_a?(Prism::SymbolNode)
+        end
+
+        # Detects `RSpec.describe(Const) do ... end` and
+        # `describe(Const) do ... end`. Either form opens a
+        # scope whose anchor is `Const`. The receiver shape
+        # (RSpec vs nil) is allowed in both cases.
+        def describe_with_constant?(node)
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless node.name == :describe
+          return false unless node.block.is_a?(Prism::BlockNode)
+
+          args = node.arguments&.arguments || []
+          first = args.first
+          first.is_a?(Prism::ConstantReadNode) || first.is_a?(Prism::ConstantPathNode)
+        end
+
+        def describe_const_name(node)
+          arg = node.arguments.arguments.first
+          render_constant_path(arg)
+        end
+
+        def render_constant_path(node)
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode
+            parts = []
+            current = node
+            while current.is_a?(Prism::ConstantPathNode)
+              parts.unshift(current.name.to_s)
+              current = current.parent
+            end
+            case current
+            when nil then "::#{parts.join('::')}"
+            when Prism::ConstantReadNode then "#{current.name}::#{parts.join('::')}"
+            end
+          end
+        end
+
+        # --- diagnostics ---
+
+        def diagnostic_for(matcher_call, path, anchor, entry)
+          lane = MATCHER_TABLE.fetch(matcher_call.name)
+          target = matcher_call.arguments.arguments.first.unescaped.to_sym
+
+          case lane
+          when :column
+            column_diagnostic(matcher_call, path, anchor, entry, target)
+          when :association_singular
+            association_diagnostic(matcher_call, path, anchor, entry, target, expected_kind: :singular)
+          when :association_collection
+            association_diagnostic(matcher_call, path, anchor, entry, target, expected_kind: :collection)
+          end
+        end
+
+        def column_diagnostic(matcher_call, path, anchor, entry, column_name)
+          return nil if entry.column?(column_name)
+
+          build_diagnostic(
+            matcher_call, path,
+            rule: "shoulda-matchers.unknown-column",
+            message: "#{matcher_call.name}(:#{column_name}) — no column `#{column_name}` on " \
+                     "#{anchor} (columns: #{entry.column_names.sort.join(', ')})"
+          )
+        end
+
+        def association_diagnostic(matcher_call, path, anchor, entry, assoc_name, expected_kind:)
+          if entry.association?(assoc_name)
+            actual = entry.association(assoc_name)[:kind]
+            return nil if actual == expected_kind
+
+            build_diagnostic(
+              matcher_call, path,
+              rule: "shoulda-matchers.association-kind-mismatch",
+              message: "#{matcher_call.name}(:#{assoc_name}) on #{anchor} — `#{assoc_name}` is " \
+                       "a #{actual} association; #{matcher_call.name} expects #{expected_kind}"
+            )
+          else
+            build_diagnostic(
+              matcher_call, path,
+              rule: "shoulda-matchers.unknown-association",
+              message: "#{matcher_call.name}(:#{assoc_name}) — no association `#{assoc_name}` on " \
+                       "#{anchor} (associations: #{entry.association_names.sort.join(', ')})"
+            )
+          end
+        end
+
+        def build_diagnostic(call_node, path, rule:, message:)
+          location = call_node.message_loc || call_node.location
+          Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            severity: :warning,
+            rule: rule,
+            message: message
+          )
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+require_relative "shoulda_matchers/analyzer"
+
+module Rigor
+  module Plugin
+    # rigor-shoulda-matchers — validates shoulda-matchers
+    # matchers against the `:model_index` cross-plugin fact
+    # (ADR-9) published by `rigor-activerecord`.
+    #
+    # The plugin walks every `RSpec.describe <ModelConst> do
+    # ... end` block and validates the matchers inside
+    # against the model's known columns / associations.
+    #
+    # ## Recognised matchers (v0.1.0)
+    #
+    # **Column matchers** (validate the named column exists on
+    # the model):
+    #
+    #   validate_presence_of(:col), validate_uniqueness_of(:col),
+    #   validate_length_of(:col), validate_numericality_of(:col),
+    #   validate_acceptance_of(:col), validate_inclusion_of(:col),
+    #   validate_exclusion_of(:col), validate_absence_of(:col),
+    #   validate_format_of(:col), validate_confirmation_of(:col),
+    #   have_db_column(:col), have_db_index(:col)
+    #
+    # **Association matchers** (validate the association exists
+    # AND its kind matches):
+    #
+    #   belong_to(:assoc), have_one(:assoc)            ← :singular
+    #   have_many(:assoc), have_and_belong_to_many(:assoc) ← :collection
+    #
+    # ## Cross-plugin dependency
+    #
+    # The plugin consumes `:model_index` from `rigor-activerecord`.
+    # When `rigor-activerecord` is NOT loaded (or hasn't
+    # published an index for the analysed model), the plugin
+    # falls silent — the cross-check is opt-in. Adding
+    # `rigor-activerecord` to `.rigor.yml` unlocks the
+    # diagnostics.
+    #
+    # ## Limitations (v0.1.0)
+    #
+    # - **No chained-matcher arg validation.** The chain
+    #   options on `validate_length_of(:col).is_at_most(50)`,
+    #   `validate_inclusion_of(:col).in_array([...])`,
+    #   `allow_value("foo").for(:col)`, etc. are NOT validated
+    #   (the `.is_at_most` etc. terminals are runtime-only).
+    # - **No polymorphic / through validation.** `belong_to(:user).polymorphic`,
+    #   `have_many(:posts, through: :memberships)` only check
+    #   the named association; the chain modifiers are
+    #   ignored.
+    # - **No nested-attribute matchers.** `accept_nested_attributes_for(:posts)`
+    #   not yet covered.
+    # - **No callback matchers.** `callback(:before_save).before(:save)`
+    #   would need a separate slice (overlaps with the
+    #   model_index's `callbacks` column already exposed but
+    #   no rspec-side recogniser yet).
+    class ShouldaMatchers < Rigor::Plugin::Base
+      manifest(
+        id: "shoulda-matchers",
+        version: "0.1.0",
+        description: "Validates shoulda-matchers matchers (validate_presence_of / belong_to / " \
+                     "have_many / have_db_column / ...) against :model_index from " \
+                     "rigor-activerecord.",
+        consumes: [
+          { plugin_id: "activerecord", name: :model_index, optional: true }
+        ]
+      )
+
+      def init(services)
+        @services = services
+        @model_index = nil
+        @model_index_resolved = false
+      end
+
+      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+        index = model_index_or_nil
+        return [] if index.nil?
+
+        Analyzer.diagnose(
+          path: path, root: root, model_index: index
+        ).map { |diag| build_diagnostic(diag) }
+      end
+
+      private
+
+      # Lazily resolves `:model_index` from
+      # `rigor-activerecord`. Returns nil when the plugin
+      # isn't loaded or no index has been published; the
+      # analyzer treats nil as "no cross-check available" and
+      # falls silent.
+      def model_index_or_nil
+        return @model_index if @model_index_resolved
+
+        @model_index = @services.fact_store.read(plugin_id: "activerecord", name: :model_index)
+        @model_index_resolved = true
+        @model_index
+      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(ShouldaMatchers)
+  end
+end

data/plugins/rigor-shoulda-matchers/lib/rigor-shoulda-matchers.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rigor/plugin/shoulda_matchers"

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class Sidekiq < Rigor::Plugin::Base
+      # Walks a parsed file's AST looking for
+      # `<WorkerClass>.perform_async(...)` /
+      # `.perform_inline(...)` / `.perform_in(time, ...)` /
+      # `.perform_at(time, ...)` calls and validates each
+      # against the {WorkerIndex}.
+      #
+      # Argument-shape rules:
+      #
+      # - `perform_async` / `perform_inline` — every
+      #   argument is forwarded to `#perform`. Validate
+      #   `actual == #perform.arity`.
+      # - `perform_in(interval, ...args)` /
+      #   `perform_at(time, ...args)` — the FIRST argument
+      #   is the schedule (a Time / Integer / ActiveSupport
+      #   duration); the rest are forwarded to `#perform`.
+      #   Validate `actual_args - 1 == #perform.arity`.
+      module Analyzer
+        # Methods that delegate to `#perform` 1:1.
+        DIRECT_ENTRY_METHODS = %i[perform_async perform_inline].freeze
+
+        # Methods whose first argument is a schedule (the
+        # remaining args are forwarded to `#perform`).
+        SCHEDULED_ENTRY_METHODS = %i[perform_in perform_at].freeze
+
+        ENTRY_METHODS = (DIRECT_ENTRY_METHODS + SCHEDULED_ENTRY_METHODS).freeze
+
+        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+
+        module_function
+
+        # @param path [String]
+        # @param root [Prism::Node]
+        # @param worker_index [WorkerIndex]
+        # @return [Array<Diagnostic>]
+        def diagnose(path:, root:, worker_index:)
+          diagnostics = []
+          walk(root) do |call_node|
+            class_name = constant_receiver_name(call_node.receiver)
+            next if class_name.nil?
+
+            entry = worker_index.find(class_name) || worker_index.find("::#{class_name}")
+            next if entry.nil?
+
+            diagnostics << info_diagnostic(path, call_node, entry)
+            arity_diag = arity_check(path, call_node, entry)
+            diagnostics << arity_diag if arity_diag
+          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, &) }
+        end
+
+        def entry_call?(node)
+          ENTRY_METHODS.include?(node.name) &&
+            (node.receiver.is_a?(Prism::ConstantReadNode) || node.receiver.is_a?(Prism::ConstantPathNode))
+        end
+
+        def info_diagnostic(path, call_node, entry)
+          location = call_node.location
+          Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            severity: :info,
+            rule: "worker-call",
+            message: "`#{entry.class_name}.#{call_node.name}` matches `#perform` " \
+                     "(arity #{entry.arity_label})"
+          )
+        end
+
+        def arity_check(path, call_node, entry)
+          all_args = (call_node.arguments&.arguments || []).size
+          # Scheduled entries consume the first arg as the
+          # schedule; the rest are forwarded.
+          forwarded_count = SCHEDULED_ENTRY_METHODS.include?(call_node.name) ? all_args - 1 : all_args
+
+          if SCHEDULED_ENTRY_METHODS.include?(call_node.name) && all_args.zero?
+            return missing_schedule_diagnostic(path, call_node, entry)
+          end
+
+          return nil if forwarded_count.negative?
+          return nil if entry.accepts?(forwarded_count)
+
+          location = call_node.location
+          Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            severity: :error,
+            rule: "wrong-arity",
+            message: "`#{entry.class_name}.#{call_node.name}` expects " \
+                     "#{describe_expected(entry, call_node.name)} forwarded to `#perform` " \
+                     "(arity #{entry.arity_label}), got #{forwarded_count}"
+          )
+        end
+
+        def missing_schedule_diagnostic(path, call_node, entry)
+          location = call_node.location
+          Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            severity: :error,
+            rule: "missing-schedule",
+            message: "`#{entry.class_name}.#{call_node.name}` requires a schedule " \
+                     "(time / interval) as its first argument, got 0 arguments"
+          )
+        end
+
+        def describe_expected(entry, method_name)
+          if SCHEDULED_ENTRY_METHODS.include?(method_name)
+            "#{entry.arity_label} argument(s) (after the schedule)"
+          else
+            "#{entry.arity_label} argument(s)"
+          end
+        end
+
+        def constant_receiver_name(node)
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode then constant_path_name(node)
+          end
+        end
+
+        def constant_path_name(node)
+          parts = []
+          current = node
+          while current.is_a?(Prism::ConstantPathNode)
+            parts.unshift(current.name.to_s)
+            current = current.parent
+          end
+          case current
+          when nil then "::#{parts.join('::')}"
+          when Prism::ConstantReadNode then "#{current.name}::#{parts.join('::')}"
+          end
+        end
+      end
+    end
+  end
+end