rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/introspectors/superclass_chain.rb

@@ -40,11 +40,12 @@ module RailsAiContext
       # @param lookup [#call, nil] constant name -> that class's source
       # @param only [String, nil] answer for this class name alone, ignoring the file's other
       #   declarations (a concern that nests a validator class declares both)
+      # @param path_name [String, nil] the constant the source's path spells, so its Class.new class counts
       # @return [Array<Link>]
-      def to(source, bases:, lookup: nil, seen: [], only: nil)
+      def to(source, bases:, lookup: nil, seen: [], only: nil, path_name: only)
         return [] if source.nil? || seen.size >= MAX_DEPTH
 
-        declarations = DeclaredConstant.declarations(source)
+        declarations = DeclaredConstant.declarations(source, path_name: path_name)
         declarations = [ DeclaredConstant.declaration_named(declarations, only) ].compact if only
         return [] if declarations.empty?
 
@@ -58,7 +59,7 @@ module RailsAiContext
           parent_source = lookup&.call(parent)
           next if parent_source.nil?
 
-          rest = to(parent_source, bases: bases, lookup: lookup, seen: seen + [ parent ])
+          rest = to(parent_source, bases: bases, lookup: lookup, seen: seen + [ parent ], path_name: parent)
           return [ Link.new(name: candidate.name, superclass: parent, source: source) ] + rest if rest.any?
         end
 
@@ -95,21 +96,13 @@ module RailsAiContext
         name == base || name.end_with?("::#{base}")
       end
 
-      # Ruby resolves a bare superclass from the enclosing namespace outward,
-      # so `Fasp::BackfillWorker < BaseWorker` means Fasp::BaseWorker where
-      # that exists and ::BaseWorker where it does not.
-      #
-      # @param declared [String] the subclass's fully qualified name
-      # @param parent [String, nil] the superclass as the source writes it
-      # @yieldparam candidate [String] a name to try, nearest scope first
-      # @return [Object, nil] the block's first truthy answer
-      def resolve_in_scope(declared, parent)
+      # A bare superclass resolves through Module.nesting: `module Fasp; class W < BaseWorker` tries Fasp::BaseWorker first.
+      # A nil `nesting` is read off the declared name, which is right for the nested form only.
+      def resolve_in_scope(declared, parent, nesting: nil)
         parent = parent.to_s.delete_prefix("::")
         return nil if parent.empty?
 
-        scope = declared.to_s.split("::")[0..-2]
-        scope.size.downto(0) do |i|
-          candidate = (scope.first(i) + [ parent ]).join("::")
+        ((nesting || nesting_of(declared)).map { |scope| "#{scope}::#{parent}" } + [ parent ]).each do |candidate|
           # `class CostQuery::Export < Export` names the top-level Export; the
           # nearest candidate is the class itself, which is nobody's parent.
           next if candidate == declared.to_s
@@ -120,6 +113,12 @@ module RailsAiContext
         nil
       end
 
+      # The nesting the nested form gives a class: every enclosing name, innermost first.
+      def nesting_of(declared)
+        scope = declared.to_s.split("::")[0..-2]
+        scope.size.downto(1).map { |i| scope.first(i).join("::") }
+      end
+
       # A callable from a constant name to the source of the file declaring
       # it, probed against the app's autoload roots rather than a walk over
       # the tree: Zeitwerk resolves a constant to one path under one root, and

data/lib/rails_ai_context/introspectors/table_name.rb

@@ -13,23 +13,18 @@ module RailsAiContext
     # namespace and the superclass chain is the caller's business, because only
     # it knows the other files.
     #
-    # It reads table_name, table_name_prefix and table_name_suffix and nothing
-    # else: a class-level `self.primary_key =` is just as invisible to the
-    # static tier, and answering one of those and not the other would be worse
-    # than answering neither.
+    # It reads table_name, table_name_prefix, table_name_suffix,
+    # pluralize_table_names and a literal `self.primary_key =`.
     module TableName
       module_function
 
-      NONE = { table_name: nil, table_name_prefix: nil, table_name_suffix: nil }.freeze
-
-      PREFIX_INDEX = Concurrent::Map.new
-      APP_AFFIXES = Concurrent::Map.new
+      NONE = { table_name: nil, table_name_prefix: nil, table_name_suffix: nil, pluralize_table_names: nil, primary_key: nil }.freeze
 
       # {"RssPolling" => "rss_polling_"}: the engine prefix no model file says.
       # ponytail: reads `lib/**/engine.rb` only; walk lib wholesale if an app needs more.
       def namespace_prefixes(root)
         root = File.expand_path(root.to_s)
-        PREFIX_INDEX.compute_if_absent(root) { read_namespace_prefixes(root) }
+        RunCache.fetch([ :namespace_prefixes, root ]) { read_namespace_prefixes(root) }
       end
 
       # A table an option writes as that source (a habtm join_table), read the
@@ -39,31 +34,18 @@ module RailsAiContext
         statements&.size == 1 ? affixed_node(statements.first, own, root) : nil
       end
 
-      def clear_namespace_prefixes
-        PREFIX_INDEX.clear
-        APP_AFFIXES.clear
-      end
-
-      # {table_name_prefix: "op_"}: what config/application.rb sets on
-      # config.active_record, the class attribute's value in every model.
-      def app_affixes(root)
-        return {} unless root
-
-        root = File.expand_path(root.to_s)
-        APP_AFFIXES.compute_if_absent(root) { read_app_affixes(root) }
-      end
-
-      # All three declarations of one class body, read in one walk.
+      # Every declaration of one class body, read in one walk.
       #
       # @param source [String] the file's source
       # @param name [String] the qualified name of the class or module
-      # @return [Hash] the three, each nil when this scope declares none
+      # @return [Hash] the five, each nil when this scope declares none
       # @param root [String, nil] the app, whose configured affixes a table
       #   name interpolating table_name_prefix or table_name_suffix reads
       def declarations(source, name, root = nil)
         read(source, name) do |body|
           own = { table_name_prefix: affix(body, :table_name_prefix), table_name_suffix: affix(body, :table_name_suffix) }
           { table_name: assigned(body, :table_name=) || interpolated(body, own, root) }.merge(own)
+            .merge(pluralize_table_names: boolean_assigned(body, :pluralize_table_names=), primary_key: primary_key_assigned(body))
         end || NONE
       end
 
@@ -77,8 +59,9 @@ module RailsAiContext
       # name already carries that inflection - Zeitwerk resolved the constant
       # from it. Underscoring the constant instead turns OAuthClientConfig into
       # o_auth_client_configs, a table no app has.
-      def stem(path)
-        File.basename(path.to_s, ".rb").pluralize
+      def stem(path, pluralize = true)
+        base = File.basename(path.to_s, ".rb")
+        pluralize ? base.pluralize : base
       end
 
       # The table a model name alone implies. The namespace is not part of it:
@@ -141,21 +124,6 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, {}, label: "namespace_prefixes")
       end
 
-      def read_app_affixes(root)
-        path = File.join(root, "config", "application.rb")
-        return {} unless File.file?(path)
-
-        Array(SourceIntrospector.walk(path, { config: Listeners::ConfigAssignmentListener })[:config])
-          .each_with_object({}) do |entry, found|
-            path = entry[:path]
-            next unless path.size == 2 && path.first == :active_record && entry[:value].is_a?(String)
-
-            found[path.last] = entry[:value] if %i[table_name_prefix table_name_suffix].include?(path.last)
-          end
-      rescue StandardError, ScriptError => e
-        RailsAiContext.debug_fail(e, {}, label: "app_affixes")
-      end
-
       def engine_files(root)
         roots = [ root ] + PathResolver.code_roots(root)
         roots.flat_map { |dir| Dir.glob(File.join(dir, "lib", "**", "engine.rb")) }.uniq.sort
@@ -207,11 +175,24 @@ module RailsAiContext
           return statements(node) if qualified == name
 
           descend(node, scope + [ segment(node) ], name)
+        when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
+          written = node.is_a?(Prism::ConstantWriteNode) ? node.name.to_s : node.target.slice.delete_prefix("::")
+          return built_body(node.value) if (scope + [ written ]).join("::") == name
+
+          descend(node, scope, name)
         else
           descend(node, scope, name)
         end
       end
 
+      # `Name = Class.new(Base) do ... end` runs the block as Name's body.
+      def built_body(value)
+        return [] unless value.is_a?(Prism::CallNode) && value.name == :new && value.receiver&.slice == "Class"
+
+        block = value.block
+        block.is_a?(Prism::BlockNode) && block.body.is_a?(Prism::StatementsNode) ? block.body.body : []
+      end
+
       def descend(node, scope, name)
         node.child_nodes.compact.each do |child|
           found = body_of(child, scope, name)
@@ -236,6 +217,26 @@ module RailsAiContext
         call && literal(call.arguments&.arguments)
       end
 
+      # A name, or a composite key's names; nil for anything computed.
+      def primary_key_assigned(body)
+        call = body.find { |node| node.is_a?(Prism::CallNode) && node.name == :primary_key= && node.receiver.is_a?(Prism::SelfNode) }
+        args = call&.arguments&.arguments
+        return literal(args) unless args&.size == 1 && args.first.is_a?(Prism::ArrayNode)
+
+        names = args.first.elements.map { |element| literal([ element ]) }
+        names if names.all?
+      end
+
+      def boolean_assigned(body, name)
+        call = body.find do |node|
+          node.is_a?(Prism::CallNode) && node.name == name && node.receiver.is_a?(Prism::SelfNode)
+        end
+        args = call&.arguments&.arguments
+        return nil unless args&.size == 1
+
+        { Prism::TrueNode => true, Prism::FalseNode => false }[args.first.class]
+      end
+
       # `self.table_name = "#{table_name_prefix}users#{table_name_suffix}"`: the class's
       # own affix, else the app's configured one.
       def interpolated(body, own, root)
@@ -253,7 +254,7 @@ module RailsAiContext
           next part.unescaped if part.is_a?(Prism::StringNode)
 
           key = affix_read(part) or return nil
-          own[key] || app_affixes(root)[key] || ""
+          own[key] || ActiveRecordSettings.for(root)[key] || ""
         end.join
       end
 
@@ -284,8 +285,8 @@ module RailsAiContext
         end
       end
 
-      private_class_method :affix, :read, :body_of, :descend, :statements, :segment,
-                           :assigned, :returned, :literal, :read_namespace_prefixes, :read_app_affixes,
+      private_class_method :affix, :read, :body_of, :built_body, :descend, :statements, :segment,
+                           :assigned, :boolean_assigned, :primary_key_assigned, :returned, :literal, :read_namespace_prefixes,
                            :interpolated, :affixed_node, :affix_read,
                            :engine_files, :collect_isolate_calls
     end