rigortype 0.1.10 → 0.1.11

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/inflector.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class Activerecord < Rigor::Plugin::Base
+      # Tiny inflection helper for the common `ClassName → snake_case_plural`
+      # mapping Rails uses to derive table names. Deliberately
+      # narrow — handles the regular cases (`User → users`,
+      # `BlogPost → blog_posts`, `Category → categories`,
+      # `Bus → buses`, `Wolf → wolves`). Irregular plurals
+      # (`Person → people`, `Mouse → mice`, `Datum → data`) are
+      # NOT handled; the user is expected to declare
+      # `self.table_name = "people"` for those.
+      #
+      # Avoids an `activesupport` runtime dependency. Rails apps
+      # that need richer inflection should set explicit table
+      # names on the affected models.
+      module Inflector
+        IRREGULAR_PLURALS = {
+          # Common ones we still want to handle without bringing
+          # in a full inflection table. Users get the configured
+          # explicit table_name route for anything else.
+          "person" => "people",
+          "child" => "children",
+          "datum" => "data"
+        }.freeze
+
+        module_function
+
+        # `BlogPost` → `blog_posts`. `User::Profile` → `user_profiles`
+        # (Rails-style namespacing flattens with underscore).
+        def tableize(class_name)
+          underscore = underscore(class_name.to_s.gsub("::", "/"))
+          # `user/profiles` → `user_profiles`
+          underscore = underscore.tr("/", "_")
+          pluralize(underscore)
+        end
+
+        # `BlogPost` → `blog_post`. Standard Rails-style underscore.
+        def underscore(camel_case_word)
+          word = camel_case_word.to_s.dup
+          word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          word.tr!("-", "_")
+          word.downcase!
+          word
+        end
+
+        # `users` → `User`, `blog_posts` → `BlogPost`.
+        # Used by the association detector to map an
+        # association NAME (`has_many :posts` → `Post`) to the
+        # target class without requiring an explicit
+        # `class_name:` option. Singularises the word first,
+        # then camel-cases. Recognises the same irregular
+        # plurals as {.pluralize}.
+        def classify(word)
+          camelize(singularize(word.to_s))
+        end
+
+        # `posts` → `post`, `categories` → `category`,
+        # `wolves` → `wolf`, `buses` → `bus`. The inverse of
+        # {.pluralize} for the regular cases this module
+        # recognises. Irregular forms (`people` → `person`)
+        # round-trip via {IRREGULAR_PLURALS}.
+        def singularize(word)
+          IRREGULAR_PLURALS.each { |singular, plural| return singular if word == plural }
+
+          case word
+          when /(.*[bcdfghjklmnpqrstvwxz])ies\z/
+            "#{Regexp.last_match(1)}y"
+          when /(.*[sxz]|.*[cs]h)es\z/
+            Regexp.last_match(0)[0..-3]
+          when /(.*)ves\z/
+            "#{Regexp.last_match(1)}f"
+          when /(.+)s\z/
+            Regexp.last_match(1)
+          else
+            word
+          end
+        end
+
+        # `blog_post` → `BlogPost`. Camelizes around `_` and
+        # `/` separators; the latter promotes namespace boundaries
+        # to `::` (Rails-style).
+        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
+
+        # `user` → `users`, `category` → `categories`,
+        # `bus` → `buses`, `wolf` → `wolves`. Falls back to a
+        # plain `+ "s"` for unrecognised endings.
+        def pluralize(word)
+          return IRREGULAR_PLURALS[word] if IRREGULAR_PLURALS.key?(word)
+
+          case word
+          when /(.*[bcdfghjklmnpqrstvwxz])y\z/
+            # `category` → `categories`, `cherry` → `cherries`
+            "#{Regexp.last_match(1)}ies"
+          when /(.*[sxz]|.*[cs]h)\z/
+            # `bus` → `buses`, `box` → `boxes`, `dish` → `dishes`
+            "#{Regexp.last_match(0)}es"
+          when /(.*)fe?\z/
+            # `wolf` → `wolves`, `knife` → `knives`
+            "#{Regexp.last_match(1)}ves"
+          else
+            "#{word}s"
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_discoverer.rb

@@ -0,0 +1,561 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class Activerecord < Rigor::Plugin::Base
+      # Walks the configured model search paths via the plugin's
+      # `IoBoundary`, parses each `.rb` file with Prism, and
+      # collects class declarations that resolve to ActiveRecord
+      # models.
+      #
+      # Discovery is a two-step pass. First every class declaration
+      # is captured as a *candidate* (its name, its superclass
+      # name, and its DSL metadata). Then a fixpoint marks a
+      # candidate as a model when its superclass is a configured
+      # base class OR (transitively) the class name of another
+      # model — this is what makes single-table-inheritance
+      # subclasses (`class Admin < User`) discoverable. Each STI
+      # child carries an `sti_parent:` pointer the {ModelIndex}
+      # uses to inherit the root model's table and DSL surface.
+      #
+      # Returns rows the {ModelIndex} consumes:
+      #
+      #   { class_name: "User", table_name_override: nil, sti_parent: nil, ... }
+      #   { class_name: "Admin", table_name_override: nil, sti_parent: "User", ... }
+      #
+      # Limitations (intentional for v0.1.0 of the plugin):
+      #
+      # - `self.table_name = "..."` recognised only when the RHS
+      #   is a String literal. Computed names
+      #   (`self.table_name = "#{tenant}_users"`) are skipped.
+      # - Modules (`class Admin::User < ApplicationRecord`) are
+      #   recognised; the resulting class name is the lexical
+      #   path (`Admin::User`).
+      # - The STI fixpoint matches a superclass name against model
+      #   class names tolerating a leading `::`; richer constant
+      #   resolution (relative namespacing) is not modelled.
+      class ModelDiscoverer
+        # @param io_boundary [Rigor::Plugin::IoBoundary]
+        # @param search_paths [Array<String>] absolute or
+        #   project-relative paths.
+        # @param base_classes [Array<String>] superclass names that
+        #   identify a class as an AR model.
+        def initialize(io_boundary:, search_paths:, base_classes:)
+          @io_boundary = io_boundary
+          @search_paths = search_paths
+          @base_classes = base_classes.to_set
+        end
+
+        # @return [Array<Hash>] rows of { class_name:, table_name_override:, sti_parent:, ... }
+        def discover
+          candidates = []
+          ruby_files_under(@search_paths).each do |path|
+            contents = read_safely(path)
+            next if contents.nil?
+
+            tree = Prism.parse(contents).value
+            walk_for_classes(tree, []) { |candidate| candidates << candidate }
+          end
+          resolve_models(candidates)
+        end
+
+        private
+
+        # Fixpoint over the captured class candidates: a candidate
+        # is a model when its superclass is a configured base
+        # class, or — transitively — the class name of an
+        # already-known model. The second arm is what discovers
+        # STI subclasses; the matched parent name is stamped onto
+        # the row as `sti_parent:` so the {ModelIndex} can inherit
+        # the root model's table and association surface.
+        #
+        # Non-model classes (POROs, service objects that happen to
+        # live under `app/models/`) never enter `model_names` and
+        # are dropped.
+        def resolve_models(candidates)
+          model_names = {}
+          sti_parent = {}
+
+          loop do
+            added = false
+            candidates.each do |candidate|
+              name = candidate[:class_name]
+              next if model_names.key?(name)
+
+              superclass = candidate[:superclass_name]
+              next if superclass.nil?
+
+              if @base_classes.include?(superclass)
+                model_names[name] = true
+                added = true
+              elsif (parent = model_match(superclass, model_names))
+                model_names[name] = true
+                sti_parent[name] = parent
+                added = true
+              end
+            end
+            break unless added
+          end
+
+          candidates.filter_map do |candidate|
+            name = candidate[:class_name]
+            next unless model_names.key?(name)
+
+            candidate.merge(sti_parent: sti_parent[name])
+          end
+        end
+
+        # Resolves a superclass NAME against the set of known
+        # model class names, tolerating a leading `::`. Returns
+        # the matched model class name, or nil.
+        def model_match(superclass_name, model_names)
+          return superclass_name if model_names.key?(superclass_name)
+
+          stripped = superclass_name.sub(/\A::/, "")
+          model_names.key?(stripped) ? stripped : nil
+        end
+
+        def read_safely(path)
+          @io_boundary.read_file(path)
+        rescue Plugin::AccessDeniedError, Errno::ENOENT
+          nil
+        end
+
+        def ruby_files_under(roots)
+          roots.flat_map do |root|
+            absolute = File.expand_path(root)
+            next [] unless File.directory?(absolute)
+
+            Dir.glob(File.join(absolute, "**", "*.rb"))
+          end
+        end
+
+        def walk_for_classes(node, lexical_path, &)
+          return if node.nil?
+
+          case node
+          when Prism::ClassNode
+            visit_class(node, lexical_path, &)
+          when Prism::ModuleNode
+            visit_module(node, lexical_path, &)
+          else
+            node.compact_child_nodes.each { |child| walk_for_classes(child, lexical_path, &) }
+          end
+        end
+
+        # Captures EVERY class declaration as a candidate — the
+        # `resolve_models` fixpoint decides afterwards which ones
+        # are models. The DSL metadata is extracted eagerly; for a
+        # non-model class it is simply discarded when the candidate
+        # is dropped.
+        def visit_class(node, lexical_path, &)
+          class_local_name = constant_path_name(node.constant_path)
+          return if class_local_name.nil?
+
+          full_name = (lexical_path + [class_local_name]).join("::")
+          superclass = constant_path_name(node.superclass) if node.superclass
+
+          yield({
+            class_name: full_name,
+            superclass_name: superclass,
+            table_name_override: lookup_table_name_override(node.body),
+            associations: lookup_associations(node.body),
+            enums: lookup_enums(node.body),
+            scopes: lookup_scopes(node.body),
+            validations: lookup_validations(node.body),
+            callbacks: lookup_callbacks(node.body),
+            aliases: lookup_aliases(node.body)
+          })
+
+          # Recurse into the body in case nested classes exist.
+          inner_path = lexical_path + [class_local_name]
+          walk_for_classes(node.body, inner_path, &) if node.body
+        end
+
+        def visit_module(node, lexical_path, &)
+          module_local_name = constant_path_name(node.constant_path)
+          return if module_local_name.nil?
+
+          inner_path = lexical_path + [module_local_name]
+          walk_for_classes(node.body, inner_path, &) if node.body
+        end
+
+        # Renders a constant-path node (`Admin::User`,
+        # `::ApplicationRecord`) as a String. Returns nil for
+        # shapes the discoverer chooses not to handle.
+        def constant_path_name(node)
+          return nil if node.nil?
+
+          case node
+          when Prism::ConstantReadNode
+            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
+              "::#{parts.join('::')}"
+            when Prism::ConstantReadNode
+              "#{current.name}::#{parts.join('::')}"
+            end
+          end
+        end
+
+        # Looks for `self.table_name = "..."` at the top level of
+        # the class body. Returns the literal String when found,
+        # nil otherwise.
+        def lookup_table_name_override(body)
+          return nil if body.nil?
+
+          body.compact_child_nodes.each do |node|
+            next unless node.is_a?(Prism::CallNode) && node.name == :table_name=
+            next unless node.receiver.is_a?(Prism::SelfNode)
+
+            arg = node.arguments&.arguments&.first
+            return arg.unescaped if arg.is_a?(Prism::StringNode)
+          end
+          nil
+        end
+
+        # Recognised single-instance and collection association
+        # DSL methods. The kind drives the eventual return-type
+        # contribution: singular associations narrow to
+        # `Nominal[Target] | nil`, plural ones currently degrade
+        # to the RBS envelope (relation types are a future track).
+        #
+        # `composed_of` value-object aggregations and
+        # `delegated_type` roles are folded in here too — both
+        # accept the association name as a `where` / `find_by`
+        # query key, so omitting them turns every such query into
+        # a false `unknown-column`. `composed_of` resolves to its
+        # value class (a real target); `delegated_type` is
+        # polymorphic (no single target).
+        ASSOCIATION_METHODS = {
+          belongs_to: :singular,
+          has_one: :singular,
+          has_many: :collection,
+          has_and_belongs_to_many: :collection,
+          composed_of: :singular,
+          delegated_type: :singular
+        }.freeze
+        private_constant :ASSOCIATION_METHODS
+
+        # Association DSL methods that are ALWAYS polymorphic —
+        # the accessor has no single static target class.
+        # `belongs_to` / `has_one` become polymorphic only with
+        # an explicit `polymorphic: true` option.
+        POLYMORPHIC_BY_DEFAULT = %i[delegated_type].freeze
+        private_constant :POLYMORPHIC_BY_DEFAULT
+
+        # Class-body declaration calls — the top-level `CallNode`s
+        # PLUS those nested inside a `with_options(...) do … end`
+        # block. `with_options` is Rails' idiom for sharing
+        # options across a group of `belongs_to` / `validates` /
+        # etc. declarations; without descending into it every
+        # association / enum / validation declared inside is
+        # invisible to the discoverer, turning `where(<assoc>:
+        # ...)` into a false `unknown-column`. Nested
+        # `with_options` blocks recurse.
+        #
+        # The options the `with_options` call itself carries (e.g.
+        # `with_options class_name: 'Account'`) are NOT merged into
+        # the nested calls — discovering the declaration name is
+        # what clears the false positive; the merged-option target
+        # precision is a separate refinement.
+        def declaration_calls(body)
+          return [] if body.nil?
+
+          body.compact_child_nodes.flat_map do |node|
+            next [] unless node.is_a?(Prism::CallNode)
+
+            if node.name == :with_options && node.block.is_a?(Prism::BlockNode)
+              declaration_calls(node.block.body)
+            else
+              [node]
+            end
+          end
+        end
+
+        # Walks the class body for association DSL calls and
+        # returns a list of rows shaped:
+        #
+        #     { name: "user", kind: :singular, target: "User" }
+        #
+        # The `target` is resolved from an explicit
+        # `class_name: "Foo"` option when supplied, otherwise
+        # inferred from the association name via
+        # {Inflector.classify}. Calls whose first arg is not a
+        # Symbol literal (or whose `class_name:` is a non-literal
+        # expression) decline rather than guess.
+        def lookup_associations(body)
+          return [] if body.nil?
+
+          rows = []
+          declaration_calls(body).each do |node|
+            kind = ASSOCIATION_METHODS[node.name]
+            next if kind.nil?
+            next if node.receiver # skip `self.has_many` and similar
+
+            row = build_association_row(node, kind)
+            rows << row unless row.nil?
+          end
+          rows
+        end
+
+        def build_association_row(node, kind)
+          args = node.arguments&.arguments
+          return nil if args.nil? || args.empty?
+
+          name_node = args.first
+          return nil unless name_node.is_a?(Prism::SymbolNode)
+
+          name = name_node.unescaped
+          polymorphic = POLYMORPHIC_BY_DEFAULT.include?(node.name) ||
+                        association_option(args, "polymorphic") == true
+
+          # A polymorphic association has no single static target
+          # class — `target` is nil and the flow contribution
+          # declines to narrow rather than inventing a wrong
+          # `Nominal[<classified-name>]`.
+          if polymorphic
+            target = nil
+          else
+            target = explicit_class_name(args) || Inflector.classify(name)
+            return nil if target.nil? || target.empty?
+          end
+
+          { name: name, kind: kind, target: target, polymorphic: polymorphic,
+            nullable: association_nullable?(node.name, args) }
+        end
+
+        # Whether a `:singular` association's accessor can return
+        # `nil`. `has_one` genuinely can (no associated record →
+        # `nil`). `belongs_to` is **required (non-`nil`) by default
+        # since Rails 5** (`belongs_to_required_by_default`); it
+        # becomes nullable only when the call passes `optional: true`
+        # or `required: false`. `composed_of` is non-nullable
+        # unless `allow_nil: true`. `delegated_type` roles are
+        # required. A non-literal option value declines to the
+        # default rather than guessing.
+        def association_nullable?(method_name, args)
+          case method_name
+          when :has_one
+            true
+          when :belongs_to
+            association_option(args, "optional") == true ||
+              association_option(args, "required") == false
+          when :composed_of
+            association_option(args, "allow_nil") == true
+          else
+            false
+          end
+        end
+
+        # Reads a literal boolean association option (`optional:` /
+        # `required:`). Returns `true` / `false` for a literal, or
+        # `nil` when the key is absent or its value is non-literal.
+        def association_option(args, key)
+          args.each do |arg|
+            next unless arg.is_a?(Prism::KeywordHashNode)
+
+            arg.elements.each do |pair|
+              next unless pair.is_a?(Prism::AssocNode) && pair.key.is_a?(Prism::SymbolNode)
+              next unless pair.key.unescaped == key
+
+              return true if pair.value.is_a?(Prism::TrueNode)
+              return false if pair.value.is_a?(Prism::FalseNode)
+            end
+          end
+          nil
+        end
+
+        def explicit_class_name(args)
+          args.each do |arg|
+            next unless arg.is_a?(Prism::KeywordHashNode)
+
+            arg.elements.each do |pair|
+              next unless pair.is_a?(Prism::AssocNode) && pair.key.is_a?(Prism::SymbolNode)
+              next unless pair.key.unescaped == "class_name"
+              next unless pair.value.is_a?(Prism::StringNode)
+
+              return pair.value.unescaped
+            end
+          end
+          nil
+        end
+
+        # `enum status: { active: 0, archived: 1 }` (Rails ≤6)
+        # and `enum :status, [:active, :archived]` (Rails 7+).
+        # Returns `Hash<column_name => Array<Symbol>>`.
+        # Non-literal forms decline rather than guess.
+        def lookup_enums(body)
+          return {} if body.nil?
+
+          enums = {}
+          declaration_calls(body).each do |node|
+            next unless node.name == :enum
+            next if node.receiver
+
+            row = parse_enum_call(node)
+            next if row.nil?
+
+            enums[row[:column]] = row[:values]
+          end
+          enums.freeze
+        end
+
+        def parse_enum_call(node)
+          args = node.arguments&.arguments
+          return nil if args.nil? || args.empty?
+
+          first = args.first
+          if first.is_a?(Prism::SymbolNode) && args.size >= 2
+            values = enum_values_from(args[1])
+            return nil if values.nil?
+
+            { column: first.unescaped, values: values }
+          elsif first.is_a?(Prism::KeywordHashNode)
+            entry = first.elements.find { |e| e.is_a?(Prism::AssocNode) && e.key.is_a?(Prism::SymbolNode) }
+            return nil if entry.nil?
+
+            values = enum_values_from(entry.value)
+            return nil if values.nil?
+
+            { column: entry.key.unescaped, values: values }
+          end
+        end
+
+        def enum_values_from(node)
+          case node
+          when Prism::ArrayNode
+            symbols = node.elements.filter_map { |e| e.unescaped if e.is_a?(Prism::SymbolNode) }
+            return nil if symbols.size != node.elements.size
+
+            symbols
+          when Prism::HashNode
+            node.elements.filter_map do |e|
+              next nil unless e.is_a?(Prism::AssocNode) && e.key.is_a?(Prism::SymbolNode)
+
+              e.key.unescaped
+            end
+          end
+        end
+
+        # `scope :active, -> { ... }`. Records the scope name
+        # only (the body is intentionally NOT introspected —
+        # scopes return ActiveRecord::Relation, which Rigor
+        # doesn't carry a precise type for yet).
+        def lookup_scopes(body)
+          return [] if body.nil?
+
+          scopes = []
+          declaration_calls(body).each do |node|
+            next unless node.name == :scope
+            next if node.receiver
+
+            args = node.arguments&.arguments
+            next if args.nil? || args.empty?
+
+            name_node = args.first
+            next unless name_node.is_a?(Prism::SymbolNode)
+
+            scopes << name_node.unescaped
+          end
+          scopes.freeze
+        end
+
+        # `validates :name, presence: true, length: { maximum: 100 }`.
+        # Records the attribute name (the validator option set
+        # is ignored — the value here is the diagnostic
+        # `validates :unknown_attr` surfacing when the attribute
+        # isn't a column on the table).
+        def lookup_validations(body)
+          return [] if body.nil?
+
+          attrs = []
+          declaration_calls(body).each do |node|
+            next unless %i[validates validates_presence_of validates_length_of
+                           validates_format_of validates_uniqueness_of].include?(node.name)
+            next if node.receiver
+
+            attrs.concat(symbol_args(node))
+          end
+          attrs.uniq.freeze
+        end
+
+        # `before_save :foo`, `after_create :bar`, etc. Records
+        # the referenced method name (a Symbol literal). The
+        # diagnostic value is "did you forget to `def` this?".
+        # Block callbacks (`before_save { ... }`) decline.
+        CALLBACK_METHODS = %i[
+          before_validation after_validation
+          before_save after_save around_save
+          before_create after_create around_create
+          before_update after_update around_update
+          before_destroy after_destroy around_destroy
+          after_commit after_rollback
+          after_initialize after_find
+        ].freeze
+        private_constant :CALLBACK_METHODS
+
+        def lookup_callbacks(body)
+          return [] if body.nil?
+
+          targets = []
+          declaration_calls(body).each do |node|
+            next unless CALLBACK_METHODS.include?(node.name)
+            next if node.receiver
+
+            symbol_args(node).each do |name|
+              targets << { name: name, callback: node.name.to_s }
+            end
+          end
+          targets.freeze
+        end
+
+        # `alias_attribute :new_name, :old_name`. Records the
+        # mapping so the analyzer accepts the alias as a query
+        # key — without it every `where(<alias>: ...)` /
+        # `find_by(<alias>: ...)` call surfaces as a false
+        # `unknown-column`. Returns `Hash<alias => target>`;
+        # non-Symbol-literal forms decline rather than guess.
+        def lookup_aliases(body)
+          return {} if body.nil?
+
+          aliases = {}
+          declaration_calls(body).each do |node|
+            next unless node.name == :alias_attribute
+            next if node.receiver
+
+            args = node.arguments&.arguments
+            next if args.nil? || args.size < 2
+
+            new_name = args[0]
+            old_name = args[1]
+            next unless new_name.is_a?(Prism::SymbolNode) && old_name.is_a?(Prism::SymbolNode)
+
+            aliases[new_name.unescaped] = old_name.unescaped
+          end
+          aliases.freeze
+        end
+
+        # Collects every Symbol-literal positional argument
+        # from a CallNode. Used by both `lookup_validations`
+        # and `lookup_callbacks` to extract the attribute /
+        # method name list.
+        def symbol_args(node)
+          args = node.arguments&.arguments
+          return [] if args.nil?
+
+          args.filter_map { |arg| arg.unescaped if arg.is_a?(Prism::SymbolNode) }
+        end
+      end
+    end
+  end
+end