rails-ai-context 5.30.2 → 5.31.0

data/lib/rails_ai_context/concern_membership.rb

@@ -14,6 +14,8 @@ module RailsAiContext
       include: %w[included append_features], prepend: %w[prepended prepend_features], extend: %w[extended]
     }.freeze
     MIXIN_HOOKS = HOOKS_BY_MACRO.values.flatten.freeze
+    # The macros that give the class a module's methods as class methods.
+    SINGLETON_MACROS = %i[extend singleton_include singleton_prepend].freeze
     # The block ActiveSupport::Concern runs for each.
     CONCERN_BLOCKS = { include: :included, prepend: :prepended }.freeze
     FRAMEWORK_PREFIXES = %w[
@@ -60,12 +62,12 @@ module RailsAiContext
 
     # Matched on the last segment: `module Edition; module Featurable` and
     # `module Edition::Featurable` both write one constant.
-    def own_mixins(mixins, name)
-      return Array(mixins) if Array(mixins).none? { |mixin| mixin.key?(:owner) }
+    def owned_by(records, name)
+      return Array(records) if Array(records).none? { |record| record.key?(:owner) }
 
-      own = own_owner(mixins, name)
+      own = own_owner(records, name)
       # `Other.include X` written in the body mixes into Other.
-      Array(mixins).select { |mixin| own && !mixin[:receiver] && Array(mixin[:owner]).join("::") == own }
+      Array(records).select { |record| own && !record[:receiver] && Array(record[:owner]).join("::") == own }
     end
 
     def own_owner(records, name)

data/lib/rails_ai_context/concern_paths.rb

@@ -133,7 +133,34 @@ module RailsAiContext
     #   bare `include DebugConcern` inside Fasp::Provider resolves at runtime
     #   to Fasp::Provider::DebugConcern, which the literal spelling misses.
     # @param dirs [Array<String>, nil] pre-resolved concern directories
-    def find_file(root, concern_name, prefer: nil, within: nil, dirs: nil)
+    # @param outer [Boolean] whether a module with no file of its own is found in its outer constant's file
+    def find_file(root, concern_name, prefer: nil, within: nil, dirs: nil, outer: true)
+      found = find_named(root, concern_name, prefer: prefer, within: within, dirs: dirs)
+      (found || (outer_named(root, concern_name, within: within, dirs: dirs) if outer))&.last
+    end
+
+    # The source of the module a reference resolves to: its file, or its own node in its outer constant's file.
+    def module_source(root, concern_name, prefer: nil, within: nil)
+      path = find_file(root, concern_name, prefer: prefer, within: within, outer: false)
+      return SafeFile.read(path) if path
+
+      name, path = outer_named(root, concern_name, within: within)
+      path && Introspectors::DeclaredConstant.module_node(AstCache.parse(path).value, name)&.slice
+    end
+
+    # [`Outer::Inner`, Outer's file] for a module with no file of its own, which Zeitwerk loads with Outer.
+    def outer_named(root, concern_name, within: nil, dirs: nil)
+      RunCache.fetch([ :outer_named, root, concern_name, within, dirs ]) do
+        candidate_names(concern_name, within).lazy.filter_map do |name|
+          outer = name.rpartition("::").first
+          path = !outer.empty? && find_file(root, outer, dirs: dirs)
+          [ name, path ] if path && Introspectors::DeclaredConstant.module_node(AstCache.parse(path).value, name)
+        end.first
+      end
+    end
+
+    # [the constant the reference resolves to, its file] for `find_file`'s file, or nil.
+    def find_named(root, concern_name, prefer: nil, within: nil, dirs: nil)
       # Wherever Zeitwerk would look, plus an in-repo path gem's lib. A lib the app does
       # not add to its autoload paths holds nothing it autoloads, so it is skipped.
       dirs = ordered_dirs(root, prefer, dirs) + PathResolver.app_roots(root) + PathResolver.declared_roots(root) +
@@ -144,8 +171,7 @@ module RailsAiContext
         next if underscore.empty? || underscore.include?("..")
 
         found = dirs.find { |dir| file_exist?(dir, "#{underscore}.rb") }
-        path = found && File.join(found, "#{underscore}.rb")
-        return path if path
+        return [ name, File.join(found, "#{underscore}.rb") ] if found
       end
 
       nil

data/lib/rails_ai_context/configuration.rb

@@ -387,8 +387,8 @@ module RailsAiContext
       @server_name         = "rails-ai-context"
       @introspectors       = PRESETS[:full].dup
       @excluded_paths      = %w[node_modules tmp log vendor .git doc docs]
-      # Files each tool's own docs say to gitignore. The patterns leave the placeholder
-      # beside one (config/application.example.yml, .env.example) readable.
+      # Files each tool's own docs say to gitignore. A placeholder beside one
+      # (config/application.example.yml, .env.example) stays readable: see SafePath.sensitive?.
       @sensitive_patterns  = %w[
         .env .env.* *.env .envrc
         config/master.key

data/lib/rails_ai_context/git_ignore.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
-
 module RailsAiContext
   # git's ignore-file rules (globs, anchoring, last match wins, negation) for
   # the doctor, and ripgrep's walk over a tree for the search fallback.
@@ -147,7 +145,7 @@ module RailsAiContext
       def global
         return @global if defined?(@global)
 
-        @global = source(@root, GitIgnore.global_excludes_path(@root))
+        @global = source(@root, GitIgnore.global_excludes_path)
       end
     end
 
@@ -169,15 +167,19 @@ module RailsAiContext
       nil
     end
 
-    # `core.excludesFile` as git resolves it from the app's directory, or the
-    # default git uses when it is unset.
-    def global_excludes_path(root)
-      configured, status = Open3.capture2("git", "config", "--get", "core.excludesFile", chdir: root)
-      configured = configured.to_s.strip
-      return File.expand_path(configured) if status.success? && !configured.empty?
-
+    # `core.excludesFile` as ripgrep 15 finds it: ~/.gitconfig, then the XDG
+    # git config, then git's default (ignore crate `gitconfig_excludes_path`).
+    def global_excludes_path
       xdg = ENV["XDG_CONFIG_HOME"].to_s
-      File.join(xdg.empty? ? File.join(Dir.home, ".config") : xdg, "git", "ignore")
+      config_dir = xdg.empty? ? File.join(Dir.home, ".config") : xdg
+      # A setting that is not UTF-8 is skipped, as ripgrep skips it.
+      configured = [ File.join(Dir.home, ".gitconfig"), File.join(config_dir, "git", "config") ].lazy.filter_map do |config|
+        path = File.file?(config) && File.binread(config)[/^\s*excludesfile\s*=\s*"?\s*(\S+?)\s*"?\s*$/i, 1]
+        path && path.force_encoding(Encoding::UTF_8).valid_encoding? ? path : nil
+      end.first
+      return File.expand_path(configured.gsub("~", Dir.home)) if configured
+
+      File.join(config_dir, "git", "ignore")
     rescue StandardError
       nil
     end

data/lib/rails_ai_context/introspectors/action_presence.rb

@@ -83,7 +83,7 @@ module RailsAiContext
       # the actions its class macros build with define_method, and an unread
       # one only hides class methods.
       def read_modules(source, owner, root, names, unread, depth)
-        mixins = ConcernMembership.own_mixins(
+        mixins = ConcernMembership.owned_by(
           SourceIntrospector.walk_source(source, { mixins: Listeners::MixinsListener })[:mixins], owner
         )
         mixins.select { |m| m[:ancestor] || (m[:macro] == :extend && !m[:receiver]) }.uniq { |m| m[:name] }.each do |mixin|
@@ -104,8 +104,10 @@ module RailsAiContext
       end
 
       def module_source(root, mod, owner)
-        path = ConcernPaths.find_file(root.to_s, mod, within: owner) ||
-               SuperclassChain.resolve_in_scope(owner, mod) { |c| PathResolver.file_for_constant(root.to_s, c) }
+        source = ConcernPaths.module_source(root.to_s, mod, within: owner)
+        return source if source
+
+        path = SuperclassChain.resolve_in_scope(owner, mod) { |c| PathResolver.file_for_constant(root.to_s, c) }
         path && SafeFile.read(path)
       end
 

data/lib/rails_ai_context/introspectors/action_resolver.rb

@@ -197,7 +197,8 @@ module RailsAiContext
       end
 
       def scanned_body(lines, method_name)
-        start_idx = lines.index { |l| l.match?(/^\s*def\s+#{Regexp.escape(method_name.to_s)}\b/i) }
+        name_end = RailsAiContext::MethodName.definition_end(method_name)
+        start_idx = lines.index { |l| l.match?(/^\s*def\s+#{Regexp.escape(method_name.to_s)}#{name_end}/i) }
         return nil unless start_idx
 
         indent = lines[start_idx][/\A\s*/].length

data/lib/rails_ai_context/introspectors/call_site_expansion.rb

@@ -12,7 +12,8 @@ module RailsAiContext
       UNKNOWN = Object.new.freeze
       # `pairs` is set for a literal hash: its `key: value` text, which reads
       # as keyword arguments where the parameter is passed as the last one.
-      Binding = Struct.new(:value, :source, :pairs, :value_sources)
+      # `items` is set for a list of literals: each one's source.
+      Binding = Struct.new(:value, :source, :pairs, :value_sources, :items)
 
       # The rewritten body, and for each of its lines the line of the mixin's
       # file it came from, so what the body declares keeps its real location.
@@ -62,7 +63,7 @@ module RailsAiContext
       def entries(definition, call, listeners)
         return {} unless definition.body
 
-        bindings = unwritten(bind(definition.parameters, call), definition.body)
+        bindings = rest_bindings(unwritten(bind(definition.parameters, call), definition.body), definition, call)
         out = Output.new
         undecided = []
         emit(definition.body, bindings, out, undecided, 0, [])
@@ -79,6 +80,16 @@ module RailsAiContext
             [ key, kept ]
           end
         end
+        unbound = bindings.filter_map { |name, binding| name if name.is_a?(Symbol) && binding.source.nil? }
+        if unbound.any?
+          data = data.transform_values do |found|
+            Array(found).reject do |entry|
+              held = names_unbound?(entry, out, unbound)
+              conditional << declaration(entry, out, []) if held
+              held
+            end
+          end
+        end
         data = data.transform_values { |found| Array(found).map { |entry| relocated(entry, out) } }
         data.merge(conditional: conditional, foreign: foreign_entries(out, listeners))
       end
@@ -128,14 +139,30 @@ module RailsAiContext
       # The call written at the entry's line, less any block, with the
       # conditions it runs under.
       def declaration(entry, out, conditions)
-        call = AstWalk.each(AstCache.parse_string(out.text).value).find do |node|
-          node.is_a?(Prism::CallNode) && node.location.start_line == entry[:location]
-        end
+        call = call_at(out, entry[:location])
         { declaration: call ? call_source(call) : out.text.lines[entry[:location] - 1].to_s.strip,
           condition: (conditions.join(" and ") if conditions.any?),
           location: out.source_line(entry[:location]) || entry[:location] }.compact
       end
 
+      def call_at(out, line)
+        AstWalk.each(AstCache.parse_string(out.text).value).find do |node|
+          node.is_a?(Prism::CallNode) && node.location.start_line == line
+        end
+      end
+
+      # A parameter the expansion cannot bind is written as its bare name, which a
+      # listener would read as what the call declares.
+      def names_unbound?(entry, out, names)
+        return false unless entry.is_a?(Hash) && entry[:location]
+
+        Array(call_at(out, entry[:location])&.arguments&.arguments).any? do |argument|
+          argument = argument.expression if argument.is_a?(Prism::SplatNode)
+          (argument.is_a?(Prism::LocalVariableReadNode) || (argument.is_a?(Prism::CallNode) && argument.variable_call?)) &&
+            names.include?(argument.name)
+        end
+      end
+
       def call_source(call)
         text = call.slice
         text = text.byteslice(0, call.block.location.start_offset - call.location.start_offset) if call.block.is_a?(Prism::BlockNode)
@@ -197,19 +224,118 @@ module RailsAiContext
         Prism::LocalVariableOrWriteNode, Prism::LocalVariableAndWriteNode
       ].freeze
 
-      # A parameter the body assigns, in a block too, no longer holds the
-      # call's argument wherever it is read, so it is bound to nothing.
+      # A parameter the body assigns or changes in place, in a block too, no
+      # longer holds the call's argument wherever it is read, so it is bound to nothing.
       def unwritten(bindings, body)
+        changed(body).each { |name| bindings[name] = unknown if bindings.key?(name) }
+        bindings
+      end
+
+      # `local[key] ||= v`, `&&=` and `+=` change the local in place too.
+      INDEX_WRITES = [ Prism::IndexOrWriteNode, Prism::IndexAndWriteNode, Prism::IndexOperatorWriteNode ].freeze
+
+      # Methods that change their receiver in place.
+      MUTATORS = %i[<< []= push append unshift prepend insert concat pop shift delete delete_at delete_if keep_if
+                    clear replace store update fill].freeze
+
+      # Readers that return an object the receiver holds, not a copy.
+      HELD_READERS = %i[[] fetch dig].freeze
+
+      # The method's own locals the body writes or changes in place, outside the `kept` statements.
+      def changed(body, kept = [])
+        found = Set.new
         stack = [ [ body, 0 ] ]
         until stack.empty?
           node, blocks = stack.pop
-          bindings[node.name] = unknown if WRITES.include?(node.class) && node.depth == blocks && bindings.key?(node.name)
+          next if kept.any? { |statement| statement.equal?(node) }
+
+          found << node.name if WRITES.include?(node.class) && node.depth == blocks
+          receiver = node.receiver if INDEX_WRITES.include?(node.class) ||
+                                      (node.is_a?(Prism::CallNode) && (MUTATORS.include?(node.name) || node.name.match?(/\w!\z/)))
+          # `options[:a][:b] = v` changes what `options` holds; `options.dup[:a] = v` changes a copy.
+          receiver = receiver.receiver while receiver.is_a?(Prism::CallNode) && HELD_READERS.include?(receiver.name)
+          found << receiver.name if receiver.is_a?(Prism::LocalVariableReadNode) && receiver.depth == blocks
           blocks += 1 if node.is_a?(Prism::BlockNode) || node.is_a?(Prism::LambdaNode)
           stack.concat(node.compact_child_nodes.map { |child| [ child, blocks ] })
         end
+        found
+      end
+
+      # `*args` holds the call's positionals past the other parameters, less a trailing hash the body takes
+      # (`extract_options!`), plus literals the leading statements push; a local changed elsewhere is unknown.
+      def rest_bindings(bindings, definition, call)
+        rest = definition.parameters&.rest
+        return bindings unless call && rest.respond_to?(:name) && rest.name && definition.body.is_a?(Prism::StatementsNode)
+
+        given = rest_arguments(definition.parameters, call)
+        taken = [ "#{rest.name}.extract_options!", "#{rest.name}.last.is_a?(Hash)?#{rest.name}.pop:{}" ]
+        kept = []
+        list = given
+        leading = true
+        definition.body.body.each do |node|
+          if node.is_a?(Prism::LocalVariableWriteNode) && taken.include?(node.value.slice.delete(" "))
+            last = given&.last
+            bindings[node.name] =
+              if given.nil? then unknown
+              elsif symbol_keyed?(last) then literal(last)
+              elsif last.nil? || literal_source?(last) then hash_binding({}, {})
+              else unknown
+              end
+            list = leading && list && (symbol_keyed?(list.last) ? list[0...-1] : list)
+            kept << node
+          elsif leading && (grown = pushed(node, rest.name, list, bindings))
+            list = grown
+            kept << node
+          else
+            leading = false
+          end
+        end
+        changed_names = changed(definition.body, kept)
+        kept.each { |node| bindings[node.name] = unknown if node.is_a?(Prism::LocalVariableWriteNode) && changed_names.include?(node.name) }
+        list = nil if !list || changed_names.include?(rest.name) || list.any? { |item| !literal_source?(item) }
+        bindings[rest.name] = list ? list_binding(list) : unknown
         bindings
       end
 
+      # The call's arguments `*rest` takes, nil when they cannot be told (a splat, too few).
+      def rest_arguments(parameters, call)
+        arguments = Array(call.arguments&.arguments)
+        return nil if arguments.any? { |argument| argument.is_a?(Prism::SplatNode) }
+
+        takes_keywords = parameters.keywords.any? || parameters.keyword_rest
+        arguments = arguments[0...-1] if takes_keywords && arguments.last.is_a?(Prism::KeywordHashNode)
+        before = parameters.requireds.size
+        after = parameters.posts.size
+        return nil if arguments.size < before + after
+
+        before += [ parameters.optionals.size, arguments.size - before - after ].min
+        arguments[before...(arguments.size - after)]
+      end
+
+      # The list `args << :x` or `args.push(:x)` leaves, under a modifier `if` the bindings decide; nil for any other statement.
+      def pushed(node, name, list, bindings)
+        return nil unless list
+
+        if node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
+          return nil if node.is_a?(Prism::IfNode) ? node.subsequent : node.else_clause
+          return nil unless node.statements&.body&.one? && (grown = pushed(node.statements.body.first, name, list, bindings))
+
+          truth = truth_of(evaluate(node.predicate, bindings.merge(name => list_binding(list)), 0))
+          return nil if truth == UNKNOWN
+
+          return (node.is_a?(Prism::UnlessNode) ? !truth : truth) ? grown : list
+        end
+        return nil unless node.is_a?(Prism::CallNode) && %i[<< push].include?(node.name) && node.block.nil?
+        return nil unless node.receiver.is_a?(Prism::LocalVariableReadNode) && node.receiver.name == name
+
+        items = Array(node.arguments&.arguments)
+        list + items if items.all? { |item| literal_source?(item) }
+      end
+
+      def list_binding(items)
+        Binding.new(items.map { |item| value_of(item) }, "[#{items.map(&:slice).join(", ")}]", nil, nil, items.map(&:slice))
+      end
+
       # A hash with symbol keys binds by its pairs' own source, whatever
       # the values are: `length: { in: 4..Proposal.max }` stands in for itself.
       def literal(node)
@@ -270,9 +396,14 @@ module RailsAiContext
       def emit(node, bindings, out, undecided, depth, conditions)
         case node
         when Prism::LocalVariableReadNode
-          source = node.depth == depth && bindings[node.name]&.source
+          source = bound(bindings, node, depth)&.source
           return out.append(source, node.location.start_line) if source
+        when Prism::InterpolatedSymbolNode, Prism::InterpolatedStringNode
+          folded = !heredoc?(node) && interpolated(node, bindings, depth)
+          return out.append(folded.inspect, node.location.start_line) if folded
         when Prism::CallNode
+          return emit_each(node, bindings, out, undecided, depth, conditions) if unrolled?(node, bindings, depth)
+
           looked_up = hash_lookup(node, bindings, depth)
           return out.append(looked_up, node.location.start_line) if looked_up
         when Prism::IfNode, Prism::UnlessNode
@@ -310,13 +441,57 @@ module RailsAiContext
         out.append(text.byteslice(position, text.bytesize - position), line_at.call(position))
       end
 
+      # The binding a read reaches: the method's parameter, or the parameter of a block written once per item.
+      def bound(bindings, node, depth)
+        level = depth - node.depth
+        level.zero? ? bindings[node.name] : bindings[[ node.name, level ]]
+      end
+
+      # `"#{field}_changed?"` with every part a literal or a bound literal, as the value it makes.
+      def interpolated(node, bindings, depth)
+        text = node.parts.map do |part|
+          next part.unescaped if part.is_a?(Prism::StringNode)
+
+          statements = part.is_a?(Prism::EmbeddedStatementsNode) && part.statements&.body
+          return nil unless statements&.one?
+
+          inner = statements.first
+          value = inner.is_a?(Prism::LocalVariableReadNode) ? bound(bindings, inner, depth)&.value : value_of(inner)
+          return nil if value.nil? || value == UNKNOWN || value.is_a?(Hash) || value.is_a?(Array)
+
+          value.to_s
+        end.join
+        node.is_a?(Prism::InterpolatedSymbolNode) ? text.to_sym : text
+      end
+
+      # `args.each do |field| ... end` over a bound list of literals.
+      def unrolled?(node, bindings, depth)
+        receiver = node.receiver
+        return false unless node.name == :each && node.arguments.nil? && node.block.is_a?(Prism::BlockNode) && node.block.body
+        return false unless receiver.is_a?(Prism::LocalVariableReadNode) && bound(bindings, receiver, depth)&.items
+
+        params = node.block.parameters&.parameters
+        params && params.requireds.one? && params.requireds.first.respond_to?(:name) && params.optionals.empty? && params.rest.nil? && params.posts.empty?
+      end
+
+      # The block's body written once per item, its parameter bound to that item.
+      def emit_each(node, bindings, out, undecided, depth, conditions)
+        name = node.block.parameters.parameters.requireds.first.name
+        binding = bound(bindings, node.receiver, depth)
+        binding.items.zip(binding.value).each do |source, value|
+          emit(node.block.body, bindings.merge([ name, depth + 1 ] => Binding.new(value, source)), out, undecided, depth + 1, conditions)
+          out.append("\n", node.location.end_line)
+        end
+        out
+      end
+
       # A call's arguments, each written from its own node and joined with a
       # comma: an argument that stands for no keywords at all (an options hash
       # left at `{}`) is left out whole, with no separator to dangle.
       def emit_arguments(node, bindings, out, undecided, depth, conditions)
         written = false
         node.arguments.each do |argument|
-          pairs = keyword_argument(node, argument, bindings, depth)
+          pairs = keyword_argument(node, argument, bindings, depth) || splatted_items(argument, bindings, depth)
           next if pairs&.empty?
 
           out.append(", ", argument.location.start_line) if written
@@ -326,12 +501,19 @@ module RailsAiContext
         out
       end
 
+      # `*names` over a bound list of literals is its items.
+      def splatted_items(argument, bindings, depth)
+        return unless argument.is_a?(Prism::SplatNode) && argument.expression.is_a?(Prism::LocalVariableReadNode)
+
+        bound(bindings, argument.expression, depth)&.items&.join(", ")
+      end
+
       # `options[:length]` on a hash parameter the call passed as a literal:
       # the value's own source, or `nil` for a key the call left out.
       def hash_lookup(node, bindings, depth)
-        return unless node.name == :[] && node.receiver.is_a?(Prism::LocalVariableReadNode) && node.receiver.depth == depth
+        return unless node.name == :[] && node.receiver.is_a?(Prism::LocalVariableReadNode)
 
-        sources = bindings[node.receiver.name]&.value_sources
+        sources = bound(bindings, node.receiver, depth)&.value_sources
         key = Array(node.arguments&.arguments)
         return unless sources && key.one? && key.first.is_a?(Prism::SymbolNode)
 
@@ -350,9 +532,7 @@ module RailsAiContext
       # `slice`, `except` or a `reject { |key| key == :x }` on it. Anything else
       # on it is not read, and the expression stays as written.
       def hash_expression(node, bindings, depth)
-        if node.is_a?(Prism::LocalVariableReadNode)
-          return node.depth == depth ? bindings[node.name]&.then { |b| b if b.value_sources } : nil
-        end
+        return bound(bindings, node, depth)&.then { |b| b if b.value_sources } if node.is_a?(Prism::LocalVariableReadNode)
         return unless node.is_a?(Prism::CallNode) && node.receiver
 
         base = hash_expression(node.receiver, bindings, depth) or return
@@ -363,7 +543,7 @@ module RailsAiContext
         when :merge
           return unless arguments.one? && symbol_keyed?(arguments.first) && node.block.nil?
 
-          added = arguments.first.elements.to_h { |pair| [ key_of(pair), pair.value.slice ] }
+          added = arguments.first.elements.to_h { |pair| [ key_of(pair), emit(pair.value, bindings, Output.new, [], depth, []).text ] }
           hash_binding(UNKNOWN, sources.merge(added))
         when :slice then keys && hash_binding(UNKNOWN, sources.slice(*keys))
         when :except then keys && hash_binding(UNKNOWN, sources.except(*keys))
@@ -465,7 +645,7 @@ module RailsAiContext
       def evaluate(node, bindings, depth)
         case node
         when Prism::LocalVariableReadNode
-          node.depth == depth ? bindings.fetch(node.name, unknown).value : UNKNOWN
+          (bound(bindings, node, depth) || unknown).value
         when Prism::ParenthesesNode
           body = node.body&.body
           body&.one? ? evaluate(body.first, bindings, depth) : UNKNOWN
@@ -502,7 +682,7 @@ module RailsAiContext
         when :[] then receiver.is_a?(Hash) ? receiver[arguments.first] : UNKNOWN
         when :key?, :has_key?, :include? then receiver.is_a?(Hash) ? receiver.key?(arguments.first) : UNKNOWN
         when :many?, :any?, :empty?, :size, :length
-          return UNKNOWN unless receiver.is_a?(Hash) && arguments.empty? && !node.block
+          return UNKNOWN unless (receiver.is_a?(Hash) || receiver.is_a?(Array)) && arguments.empty? && !node.block
 
           node.name == :many? ? receiver.size > 1 : receiver.public_send(node.name)
         when :fetch

data/lib/rails_ai_context/introspectors/controller_introspector.rb

@@ -290,10 +290,10 @@ module RailsAiContext
       # would have Rails dispatch to; the routes decide which are actions.
       def concern_actions(concerns, within, filters)
         Array(concerns).flat_map do |concern|
-          path = ConcernPaths.find_file(app.root.to_s, concern.to_s, prefer: "controller", within: within)
-          next [] unless path
+          source = ConcernPaths.module_source(app.root.to_s, concern.to_s, prefer: "controller", within: within)
+          next [] unless source
 
-          offered = (@concern_actions ||= {})[path] ||= (source = SafeFile.read(path)) ? ActionResolver.module_actions(source) : []
+          offered = (@concern_actions ||= {})[source] ||= ActionResolver.module_actions(source)
           ActionResolver.deliverable_actions(offered, filter_names(filters))
         end.uniq
       rescue => e

data/lib/rails_ai_context/introspectors/declared_constant.rb

@@ -157,17 +157,26 @@ module RailsAiContext
       # @param root [Prism::Node] the file's parse tree
       # @return [Prism::ModuleNode, nil]
       def module_node(root, name)
-        constants(root).find { |qualified, node| node.is_a?(Prism::ModuleNode) && qualified == name }&.[](1)
+        module_nodes(root)[name]
       end
 
-      # Every module the tree declares, by qualified name, the first one
-      # `module_node` would find for each: one walk for many lookups.
+      # Every module the tree declares, by qualified name: the first that is
+      # not a stub, as a namespace stub above the definition is not it.
       #
       # @return [Hash{String => Prism::ModuleNode}]
       def module_nodes(root)
-        constants(root).each_with_object({}) do |(qualified, node), found|
-          found[qualified] ||= node if node.is_a?(Prism::ModuleNode)
-        end
+        constants(root).select { |_, node| node.is_a?(Prism::ModuleNode) }
+                       .group_by(&:first).transform_values { |found| definition(found.map { |_, node| node }) }
+      end
+
+      # Of the nodes writing one constant, the one defining it: the first that is not a stub.
+      def definition(nodes)
+        nodes.find { |node| !stub?(node) } || nodes.first
+      end
+
+      # A class or module holding nothing but such stubs: `module Acts; module Journalized; end; end`.
+      def stub?(node)
+        Array(node.body&.compact_child_nodes).all? { |child| (child.is_a?(Prism::ModuleNode) || child.is_a?(Prism::ClassNode)) && stub?(child) }
       end
 
       # Each class and module the tree declares, in source order: its

data/lib/rails_ai_context/introspectors/job_introspector.rb

@@ -77,12 +77,15 @@ module RailsAiContext
           end
 
           queue = job.queue_name
-          # ActiveJob defaults queue_name to a lambda; any other Proc is a
-          # queue_as block, and only the source says what it computes.
+          # The default is a lambda; another Proc is a queue_as block, and a
+          # Proc argument is stored as its inspect string, with the line that set it.
           if queue.equal?(ActiveJob::Base.queue_name)
             queue = job.queue_name_from_part(nil)
           elsif queue.is_a?(Proc)
-            queue = (job_candidates.key?(job.name) && inherited_queue(job.name)) || COMPUTED_QUEUE
+            queue = labelled(COMPUTED_QUEUE, queue.source_location && block_at(*queue.source_location))
+          elsif queue.to_s.include?("#<Proc:")
+            location = queue.match(/#<Proc:0x\h+ (.+):(\d+)(?: \(lambda\))?>/)
+            queue = labelled(PROC_QUEUE, location && proc_at(location[1], location[2].to_i))
           end
 
           {
@@ -139,7 +142,39 @@ module RailsAiContext
       end
 
       def inherited_queue(name)
-        chain_of(name).lazy.filter_map { |link| queue_as(job_candidates[link].ast[:macros]) }.first
+        chain_of(name).lazy.filter_map { |link| queue_as(job_candidates[link].ast) }.first
+      end
+
+      def labelled(label, source)
+        source ? "#{label}: `#{source}`" : label
+      end
+
+      def block_at(file, line)
+        queue_as_walk(file)&.dig(:macros)&.find { |m| m[:macro] == :queue_as && m[:location] == line && m[:block] }&.dig(:block)
+      end
+
+      # Only one Proc literal on the line says which one it was.
+      def proc_at(file, line)
+        found = queue_as_walk(file)&.dig(:procs)&.select { |literal| literal[:line] == line } || []
+        found.first[:source] if found.one?
+      end
+
+      # Only the app's own files are read; a job file reuses the walk that found it.
+      def queue_as_walk(file)
+        @queue_as_walks ||= {}
+        @queue_as_walks.fetch(file) do
+          @queue_as_walks[file] = begin
+            real = File.realpath(file)
+            root = app.root.to_s
+            if SourceScan.under_root?(file, real, root, app_root_real)
+              relative = SourceScan.relative_file(file, real, root, app_root_real)
+              job_candidates.values.find { |candidate| candidate.file == relative }&.ast ||
+                (source = SafeFile.read(file)) && SourceIntrospector.walk_source(source, QUEUE_AS_LISTENERS)
+            end
+          rescue SystemCallError
+            nil
+          end
+        end
       end
 
       # This class and its ancestors among the candidates, nearest first.
@@ -153,17 +188,28 @@ module RailsAiContext
       end
 
       COMPUTED_QUEUE = "computed by a block"
+      PROC_QUEUE = "queue_as given a Proc: ActiveJob does not call it, so the queue is named after the Proc's text"
+      PROC_LITERAL = /\A(?:->|(?:lambda|proc|Proc\.new)(?![\w.]))/
+
+      QUEUE_AS_LISTENERS = {
+        macros: -> { Listeners::GenericMacroListener.new(*JOB_MACROS, block_source: [ :queue_as ]) },
+        procs:  Listeners::ProcLiteralListener
+      }.freeze
 
       # A literal queue by name; one picked at enqueue time by the source that
       # picks it, the way other computed values read.
-      def queue_as(macros)
-        hit = macros.find { |m| m[:macro] == :queue_as } or return nil
+      def queue_as(ast)
+        hit = ast[:macros].find { |m| m[:macro] == :queue_as } or return nil
         return hit[:args].first.to_s if hit[:args].any?
+        return labelled(COMPUTED_QUEUE, hit[:block]) if hit[:block]
 
         source = hit[:values].first.to_s.gsub(/\s+/, " ").strip
         return COMPUTED_QUEUE if source.empty?
 
-        source.start_with?("->", "lambda", "proc") ? "#{COMPUTED_QUEUE}: `#{source}`" : "`#{source}` (computed)"
+        assigned = Array(ast[:procs]).find { |literal| literal[:constant] == source }
+        return labelled(PROC_QUEUE, assigned[:source]) if assigned
+
+        source.match?(PROC_LITERAL) ? labelled(PROC_QUEUE, source) : "`#{source}` (computed)"
       end
 
       def sidekiq_options(macros)
@@ -321,11 +367,10 @@ module RailsAiContext
               declared: declaration.name,
               declares: declarations.map(&:name),
               superclass: declaration.superclass,
-              ast: SourceIntrospector.walk_source(record.source, {
-                macros:  -> { Listeners::GenericMacroListener.new(*JOB_MACROS) },
+              ast: SourceIntrospector.walk_source(record.source, QUEUE_AS_LISTENERS.merge(
                 methods: Listeners::MethodsListener,
                 calls:   SourceCalls.listener
-              })
+              ))
             )
           end
         end

data/lib/rails_ai_context/introspectors/listeners/base_listener.rb

@@ -322,9 +322,9 @@ module RailsAiContext
           end
         end
 
-        def confidence_for(node)
-          RailsAiContext::Confidence.for_node(node)
-        end
+        def confidence_for(node) = self.class.confidence_for(node)
+
+        def self.confidence_for(node) = RailsAiContext::Confidence.for_node(node)
       end
     end
   end