rigortype 0.1.9 → 0.1.11

data/plugins/rigor-dry-validation/sig/dry_validation.rbs

@@ -0,0 +1,25 @@
+# RBS overlay for dry-validation core. Users add this directory
+# to their `.rigor.yml`'s `signature_paths:` so
+# `contract.call(input).to_h` chains type cleanly.
+#
+# This is the slice-1 floor — `Contract#call` returns the generic
+# `Result`. Slice 2 (deferred) will refine `Result#to_h` per-contract
+# by consuming the `:dry_schema_table` fact published by
+# rigor-dry-schema.
+
+module Dry
+  module Validation
+    class Contract
+      def call: (Hash[Symbol, untyped]) -> Result
+              | (untyped) -> Result
+    end
+
+    class Result
+      def success?: () -> bool
+      def failure?: () -> bool
+      def to_h: () -> Hash[Symbol, untyped]
+      def errors: () -> untyped
+      def []: (Symbol) -> untyped
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+require "prism"
+
+module Rigor
+  module Plugin
+    class Factorybot < Rigor::Plugin::Base
+      # Per-file walker — visits every `FactoryBot.<entry>(...)`
+      # call (and the `FactoryGirl` legacy alias) and validates
+      # the factory name + the keyword-argument attribute keys
+      # against the per-run {FactoryIndex}.
+      #
+      # Recognised entry methods cover the canonical create /
+      # build / build_stubbed / attributes_for family; the same
+      # validation applies to every entry (the runtime semantics
+      # differ — one persists, one returns a hash — but the
+      # call-site shape is identical from the static check's
+      # perspective).
+      module Analyzer
+        ENTRY_METHODS = %i[create build build_stubbed attributes_for create_list build_list build_stubbed_list].freeze
+
+        Diagnostic = Data.define(:path, :line, :column, :message, :severity, :rule)
+
+        module_function
+
+        def diagnose(path:, root:, factory_index:, model_index: nil)
+          diagnostics = []
+          spell_checker = DidYouMean::SpellChecker.new(dictionary: factory_index.names)
+
+          walk_entry_calls(root) do |call_node|
+            factory_name = first_positional_symbol_or_string(call_node)
+            next if factory_name.nil?
+
+            entry = factory_index.find(factory_name)
+            diagnostics.concat(
+              diagnostics_for_call(path, call_node, factory_name, entry, spell_checker, model_index)
+            )
+          end
+
+          diagnostics
+        end
+
+        # Walk the AST yielding only call nodes whose receiver
+        # is `FactoryBot` (or the `FactoryGirl` legacy alias)
+        # and whose method name is in {ENTRY_METHODS}.
+        def walk_entry_calls(node, &)
+          return unless node.is_a?(Prism::Node)
+
+          yield node if entry_call?(node)
+          node.compact_child_nodes.each { |child| walk_entry_calls(child, &) }
+        end
+
+        def entry_call?(node)
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless ENTRY_METHODS.include?(node.name)
+
+          factorybot_receiver?(node.receiver)
+        end
+
+        def factorybot_receiver?(receiver)
+          return false unless receiver.is_a?(Prism::ConstantReadNode) ||
+                              receiver.is_a?(Prism::ConstantPathNode)
+
+          name = case receiver
+                 when Prism::ConstantReadNode then receiver.name.to_s
+                 when Prism::ConstantPathNode then receiver.name.to_s
+                 end
+          %w[FactoryBot FactoryGirl].include?(name)
+        end
+
+        def first_positional_symbol_or_string(call_node)
+          first_arg = call_node.arguments&.arguments&.first
+          case first_arg
+          when Prism::SymbolNode then first_arg.value
+          when Prism::StringNode then first_arg.unescaped
+          end
+        end
+
+        def diagnostics_for_call(path, call_node, factory_name, entry, spell_checker, model_index)
+          return [unknown_factory_diagnostic(path, call_node, factory_name, spell_checker)] if entry.nil?
+
+          unknown_attribute_diagnostics(path, call_node, entry, model_index) +
+            [factory_call_diagnostic(path, call_node, factory_name, entry)]
+        end
+
+        # The keyword-argument attribute keys come from the
+        # trailing `Prism::KeywordHashNode` (Ruby's
+        # `name: "value"` syntax). Each AssocNode whose key is
+        # a `Prism::SymbolNode` is treated as a literal
+        # attribute reference.
+        #
+        # Phase 1 (c) — when `model_index` (the cross-plugin
+        # `:model_index` fact published by rigor-activerecord)
+        # is present, the effective accepted key set is the
+        # UNION of the factory's declared attributes plus the
+        # corresponding model's columns. FactoryBot's runtime
+        # accepts any AR attribute regardless of whether the
+        # factory declared it, so the cross-check broadens the
+        # acceptance accordingly.
+        def unknown_attribute_diagnostics(path, call_node, entry, model_index)
+          accepted_keys, suggestion_dictionary = effective_keys(entry, model_index)
+          attr_spell_checker = DidYouMean::SpellChecker.new(dictionary: suggestion_dictionary)
+          attribute_assoc_nodes(call_node).filter_map do |assoc|
+            next unless assoc.key.is_a?(Prism::SymbolNode)
+
+            attr_name = assoc.key.value
+            next if accepted_keys.include?(attr_name)
+
+            unknown_attribute_diagnostic(path, assoc, entry, attr_name, attr_spell_checker)
+          end
+        end
+
+        def effective_keys(entry, model_index)
+          factory_keys = entry.attribute_names
+          return [factory_keys, factory_keys] if model_index.nil?
+
+          model_class = model_class_for(entry.name)
+          model_entry = model_index[model_class]
+          return [factory_keys, factory_keys] if model_entry.nil?
+
+          model_columns = model_entry[:columns] || []
+          [(factory_keys + model_columns).uniq.freeze, (factory_keys + model_columns).uniq.freeze]
+        end
+
+        # Convention: `:user` → `User`, `:order_item` →
+        # `OrderItem`. Mirrors rigor-actionpack Phase 1's
+        # convention; namespaced models (`:admin_user` →
+        # `Admin::User`) are deferred.
+        def model_class_for(factory_name)
+          factory_name.to_s.split("_").map(&:capitalize).join
+        end
+
+        def attribute_assoc_nodes(call_node)
+          args = call_node.arguments&.arguments || []
+          last = args.last
+          return [] unless last.is_a?(Prism::KeywordHashNode)
+
+          last.elements.grep(Prism::AssocNode)
+        end
+
+        def factory_call_diagnostic(path, call_node, factory_name, entry)
+          loc = call_node.message_loc || call_node.location
+          attrs = entry.attribute_names.empty? ? "(no attributes)" : entry.attribute_names.join(", ")
+          Diagnostic.new(
+            path: path, line: loc.start_line, column: loc.start_column + 1,
+            message: "FactoryBot.#{call_node.name}(:#{factory_name}) — declared attributes: #{attrs}.",
+            severity: :info, rule: "factory-call"
+          )
+        end
+
+        def unknown_factory_diagnostic(path, call_node, factory_name, spell_checker)
+          loc = call_node.message_loc || call_node.location
+          base = "FactoryBot.#{call_node.name}(:#{factory_name}) — factory not declared in any " \
+                 "factory_search_paths file."
+          suggestion = spell_checker.correct(factory_name).first
+          message = suggestion ? "#{base} Did you mean `:#{suggestion}`?" : base
+          Diagnostic.new(
+            path: path, line: loc.start_line, column: loc.start_column + 1,
+            message: message, severity: :error, rule: "unknown-factory"
+          )
+        end
+
+        def unknown_attribute_diagnostic(path, assoc, entry, attr_name, spell_checker)
+          loc = assoc.key.location
+          base = "FactoryBot factory `:#{entry.name}` has no declared attribute `:#{attr_name}`."
+          suggestion = spell_checker.correct(attr_name).first
+          message = suggestion ? "#{base} Did you mean `:#{suggestion}`?" : base
+          Diagnostic.new(
+            path: path, line: loc.start_line, column: loc.start_column + 1,
+            message: message, severity: :error, rule: "unknown-attribute"
+          )
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_discoverer.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "factory_index"
+
+module Rigor
+  module Plugin
+    class Factorybot < Rigor::Plugin::Base
+      # Walks `factory_search_paths` and parses each `.rb` file
+      # into a {FactoryIndex}. The search-path list contains
+      # both directory paths (recursively walked) and direct
+      # file paths (read once); the typical default
+      # `["spec/factories", "spec/factories.rb"]` covers both
+      # the multi-file convention RSpec uses today and the
+      # legacy single-file form.
+      #
+      # The walker recognises:
+      #
+      # - `factory :users do ... end` — symbol form
+      # - `factory "users" do ... end` — string form
+      # - `factory :users, aliases: [:author] do ... end` — alias form
+      #
+      # Inside a factory block, attribute declarations come in
+      # several shapes. Phase 1 (a) recognises the literal-name
+      # forms only (Symbol arg / String arg):
+      #
+      # - `name { "Alice" }` — implicit attribute via
+      #   `method_missing` with a block (FactoryBot's modern
+      #   syntax)
+      # - `name "Alice"` — implicit attribute via
+      #   `method_missing` with a positional argument (legacy)
+      # - `add_attribute(:name) { "Alice" }` — the explicit
+      #   form
+      #
+      # Sequences (`sequence(:email) { ... }`), associations
+      # (`association :author`), traits, and parent / child
+      # relationships are deferred to later slices.
+      class FactoryDiscoverer
+        def initialize(io_boundary:, search_paths:)
+          @io_boundary = io_boundary
+          @search_paths = search_paths
+        end
+
+        # @return [FactoryIndex]
+        def discover
+          entries = {}
+          ruby_files_under(@search_paths).each do |path|
+            harvest(path, entries)
+          end
+          FactoryIndex.new(entries.freeze)
+        end
+
+        private
+
+        def ruby_files_under(roots)
+          roots.flat_map do |root|
+            absolute = File.expand_path(root)
+            if File.file?(absolute)
+              [absolute]
+            elsif File.directory?(absolute)
+              Dir.glob(File.join(absolute, "**", "*.rb"))
+            else
+              []
+            end
+          end
+        end
+
+        def harvest(path, entries)
+          contents = @io_boundary.read_file(path)
+          parse_result = Prism.parse(contents)
+          return unless parse_result.errors.empty?
+
+          walk_for_factories(parse_result.value) do |factory_name, attribute_names, model_class|
+            entries[factory_name] = FactoryIndex::Entry.new(
+              name: factory_name,
+              attribute_names: attribute_names.uniq.freeze,
+              model_class: model_class
+            )
+          end
+        rescue Plugin::AccessDeniedError, Errno::ENOENT
+          nil
+        end
+
+        # Yields `(factory_name, [attribute_names])` for every
+        # `factory :name do ... end` call discovered in the
+        # subtree. The walker recurses into top-level wrapping
+        # blocks (`FactoryBot.define do ... end`) and into
+        # arbitrary container nodes so factories inside `module`
+        # / `class` blocks are still picked up.
+        def walk_for_factories(node, &)
+          return unless node.is_a?(Prism::Node)
+
+          if factory_call?(node)
+            visit_factory(node, &)
+            return
+          end
+          node.compact_child_nodes.each { |child| walk_for_factories(child, &) }
+        end
+
+        def factory_call?(node)
+          node.is_a?(Prism::CallNode) && node.name == :factory && node.receiver.nil?
+        end
+
+        def visit_factory(call_node)
+          factory_name = literal_name_arg(call_node)
+          return if factory_name.nil?
+
+          attribute_names = collect_attribute_names(call_node.block)
+          model_class = factory_model_class(call_node, factory_name)
+          yield factory_name, attribute_names, model_class
+        end
+
+        def literal_name_arg(call_node)
+          first_arg = call_node.arguments&.arguments&.first
+          case first_arg
+          when Prism::SymbolNode then first_arg.value
+          when Prism::StringNode then first_arg.unescaped
+          end
+        end
+
+        # Pillar 2 Slice 3 — resolve the model class name for
+        # the factory. Three sources, in priority order:
+        #
+        # 1. Explicit `class: <Const>` keyword arg —
+        #    ConstantReadNode / ConstantPathNode value.
+        # 2. Explicit `class: "<name>"` keyword arg — String
+        #    value (supports `"Admin::User"`).
+        # 3. Inflected from the factory name — `:user` →
+        #    `"User"`, `:admin_user` → `"AdminUser"`. The
+        #    factory name is already singular by FactoryBot
+        #    convention, so we only need camelization.
+        #
+        # Returns a String (the canonical class name).
+        def factory_model_class(call_node, factory_name)
+          explicit = explicit_class_option(call_node)
+          return explicit if explicit
+
+          camelize(factory_name)
+        end
+
+        def explicit_class_option(call_node)
+          kwargs = factory_keyword_args(call_node)
+          return nil if kwargs.nil?
+
+          class_pair = kwargs.elements.find do |elem|
+            elem.is_a?(Prism::AssocNode) &&
+              elem.key.is_a?(Prism::SymbolNode) &&
+              elem.key.value == "class"
+          end
+          return nil if class_pair.nil?
+
+          render_class_value(class_pair.value)
+        end
+
+        def factory_keyword_args(call_node)
+          args = call_node.arguments&.arguments || []
+          last = args.last
+          last.is_a?(Prism::KeywordHashNode) || last.is_a?(Prism::HashNode) ? last : nil
+        end
+
+        def render_class_value(node)
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode then render_constant_path(node)
+          when Prism::StringNode then node.unescaped
+          end
+        end
+
+        def render_constant_path(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
+
+        # Pure-Ruby camelize for the factory-name fallback.
+        # `user` → `User`, `blog_post` → `BlogPost`, `admin_user`
+        # → `AdminUser`. Factory names with `/` separators
+        # (`admin/user`) camelize per-segment and join with `::`
+        # (`Admin::User`), mirroring Rails inflection.
+        def camelize(snake)
+          snake.to_s.split("/").map do |segment|
+            segment.split("_").map { |part| part.empty? ? part : part[0].upcase + part[1..] }.join
+          end.join("::")
+        end
+
+        def collect_attribute_names(block_node)
+          return [] unless block_node.is_a?(Prism::BlockNode)
+
+          attributes = []
+          collect_attributes_from(block_node.body, attributes)
+          attributes
+        end
+
+        # Walks the block body collecting attribute names. The
+        # recogniser looks at top-level statements only —
+        # attributes inside `trait :admin do ... end` or other
+        # nested blocks are NOT collected in Phase 1 (a)
+        # (traits ship in a follow-up).
+        def collect_attributes_from(node, accumulator)
+          return unless node.is_a?(Prism::Node)
+
+          if node.is_a?(Prism::StatementsNode)
+            node.body.each { |stmt| record_attribute(stmt, accumulator) }
+          else
+            record_attribute(node, accumulator)
+          end
+        end
+
+        def record_attribute(node, accumulator)
+          return unless node.is_a?(Prism::CallNode) && node.receiver.nil?
+          # Skip association / sequence / trait / framework
+          # methods — Phase 1 (a) only records plain attribute
+          # declarations.
+          return if SKIPPED_METHODS.include?(node.name)
+
+          name = if node.name == :add_attribute
+                   literal_name_arg(node)
+                 else
+                   # method_missing form: the call's method
+                   # name IS the attribute name.
+                   node.name.to_s
+                 end
+          accumulator << name if name
+        end
+
+        SKIPPED_METHODS = %i[
+          association sequence trait traits initialize_with
+          factory after before to_create skip_create
+        ].freeze
+        private_constant :SKIPPED_METHODS
+      end
+    end
+  end
+end

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_index.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class Factorybot < Rigor::Plugin::Base
+      # Per-run frozen index of discovered FactoryBot factories
+      # and the attribute keys each declares. Phase 1 (a) keys
+      # only the **literal symbol/string** factory name + the
+      # **literal symbol** attribute names; sequences,
+      # parent/child relationships, traits, and dynamically-
+      # named factories ship behind later slices.
+      #
+      # v0.2.0 (Pillar 2 Slice 3) adds `model_class` to each
+      # entry — the inferred or explicit class the factory
+      # builds. Resolved from:
+      #
+      #   1. An explicit `factory :user, class: User do`
+      #      keyword option (ConstantReadNode / ConstantPathNode
+      #      value).
+      #   2. An explicit `factory :user, class: "User"` keyword
+      #      option (String value, supports `"Admin::User"`).
+      #   3. Fallback: inflected from the factory name —
+      #      `:user` → `"User"`, `:admin_user` → `"AdminUser"`.
+      #
+      # The structure is intentionally flat: one entry per
+      # factory name. Attribute lists deduplicate.
+      class FactoryIndex
+        Entry = Data.define(:name, :attribute_names, :model_class)
+
+        attr_reader :entries
+
+        def initialize(entries)
+          @entries = entries.freeze
+          freeze
+        end
+
+        # @return [Entry, nil]
+        def find(factory_name)
+          @entries[factory_name.to_s]
+        end
+
+        def known?(factory_name)
+          @entries.key?(factory_name.to_s)
+        end
+
+        def names
+          @entries.keys
+        end
+
+        def empty?
+          @entries.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+require_relative "factorybot/analyzer"
+require_relative "factorybot/factory_discoverer"
+require_relative "factorybot/factory_index"
+
+module Rigor
+  module Plugin
+    # rigor-factorybot — validates `FactoryBot.create(:name,
+    # key: ...)` and the build / build_stubbed /
+    # attributes_for / *_list family against a per-run index
+    # built from `factory_search_paths`.
+    #
+    # **Phase 1 (a)** of the FactoryBot plugin family — the
+    # self-contained slice. Recognises factory NAMES + literal
+    # ATTRIBUTE KEYS in the call's keyword hash. Phase 1 (c)
+    # ships the AR column cross-check via the
+    # `rigor-activerecord` `:model_index` ADR-9 fact, after
+    # `rigor-activerecord` adds the matching publish hook.
+    # Traits, sequences, parent / child factories, and dynamic
+    # factory names are deferred to follow-up slices.
+    #
+    # ## Configuration
+    #
+    #     plugins:
+    #       - gem: rigor-factorybot
+    #         config:
+    #           factory_search_paths:
+    #             - spec/factories
+    #             - spec/factories.rb
+    #             # Minitest projects override:
+    #             # - test/factories
+    #
+    # ## What it checks
+    #
+    # - **Factory existence** — every entry call's first
+    #   positional Symbol / String literal is looked up in
+    #   the index. Missing factories emit `unknown-factory`
+    #   with a `DidYouMean` suggestion.
+    # - **Attribute key existence** — every literal-Symbol
+    #   keyword-argument key is matched against the factory's
+    #   declared attribute names. Missing keys emit
+    #   `unknown-attribute` with a `DidYouMean` suggestion.
+    # - **Trace** — recognised entry calls also emit a
+    #   `factory-call` info diagnostic listing the factory's
+    #   declared attribute set.
+    #
+    # ## Recognised entry methods
+    #
+    # `FactoryBot.create`, `.build`, `.build_stubbed`,
+    # `.attributes_for`, `.create_list`, `.build_list`,
+    # `.build_stubbed_list`. The legacy `FactoryGirl` constant
+    # is recognised identically. Implicit-receiver calls
+    # (`create(:name)` inside an `include FactoryBot::Syntax::Methods`
+    # context) are NOT recognised in Phase 1 (a) — too many
+    # false positives on plain `create` calls outside test
+    # files; this needs receiver-type inference (Phase 1 (b)).
+    #
+    # ## What's recognised inside `factory :name do ... end`
+    #
+    # - `name { "Alice" }` — implicit attribute via
+    #   `method_missing` with a block (modern syntax).
+    # - `name "Alice"` — implicit attribute with a positional
+    #   argument (legacy syntax).
+    # - `add_attribute(:name) { "Alice" }` — explicit form.
+    #
+    # Sequences (`sequence(:email) { ... }`), associations
+    # (`association :author`), traits (`trait :admin do ... end`),
+    # and parent / child relationships (`factory :admin,
+    # parent: :user do ... end`) are deferred to follow-up
+    # slices. Factories whose name is a non-literal expression
+    # (`factory FACTORY_NAME do ... end`) are silently skipped.
+    class Factorybot < Rigor::Plugin::Base
+      manifest(
+        id: "factorybot",
+        version: "0.2.0",
+        description: "Validates FactoryBot.create / build / attributes_for call shapes; " \
+                     "publishes per-factory attribute set + inferred model class as the " \
+                     ":factory_index ADR-9 fact (Pillar 2 Slice 3).",
+        config_schema: {
+          "factory_search_paths" => :array
+        },
+        consumes: [
+          { plugin_id: "activerecord", name: :model_index, optional: true }
+        ]
+      )
+
+      DEFAULT_FACTORY_SEARCH_PATHS = [
+        "spec/factories",
+        "spec/factories.rb"
+      ].freeze
+
+      producer :factory_index do |_params|
+        FactoryDiscoverer.new(
+          io_boundary: io_boundary,
+          search_paths: @factory_search_paths
+        ).discover
+      end
+
+      def init(services)
+        @services = services
+        @factory_search_paths = Array(
+          config.fetch("factory_search_paths", DEFAULT_FACTORY_SEARCH_PATHS)
+        ).map(&:to_s)
+        @factory_index = nil
+        @model_index = nil
+        @model_index_resolved = false
+      end
+
+      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+        index = factory_index_or_nil
+        return [] if index.nil? || index.empty?
+
+        Analyzer.diagnose(
+          path: path, root: root,
+          factory_index: index, model_index: model_index_or_nil
+        ).map { |diag| build_diagnostic(diag) }
+      end
+
+      private
+
+      # Phase 1 (c) — lazily resolves the :model_index fact
+      # from rigor-activerecord. Returns nil when
+      # rigor-activerecord isn't loaded or hasn't published
+      # an index; the analyzer treats nil as "no cross-check"
+      # and falls back to Phase 1 (a) behaviour (factory
+      # attributes only).
+      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 factory_index_or_nil
+        return @factory_index if @factory_index
+
+        prime_io_boundary_for_index
+        @factory_index = cache_for(:factory_index, params: {}).call
+      rescue StandardError
+        nil
+      end
+
+      def prime_io_boundary_for_index
+        @factory_search_paths.each do |root|
+          absolute = File.expand_path(root)
+          if File.file?(absolute)
+            safely_read(absolute)
+          elsif File.directory?(absolute)
+            Dir.glob(File.join(absolute, "**", "*.rb")).each { |p| safely_read(p) }
+          end
+        end
+      end
+
+      def safely_read(path)
+        io_boundary.read_file(path)
+      rescue Plugin::AccessDeniedError, Errno::ENOENT
+        nil
+      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(Factorybot)
+  end
+end

data/plugins/rigor-factorybot/lib/rigor-factorybot.rb

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