rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/introspectors/test_introspector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "pathname"
+
 module RailsAiContext
   module Introspectors
     # Discovers test infrastructure: framework, factories/fixtures,
@@ -10,20 +12,34 @@ module RailsAiContext
 
       TEST_FILE_GLOB = "*_{spec,test}.rb"
 
+      # An engine's test/dummy is tested by the engine's suite.
+      def suite_root
+        @suite_root ||= PathResolver.test_root(root)
+      end
+
+      RAILS_CI = "config/ci.rb"
+
       def call
+        ci_steps, ci_steps_dir = detect_ci_steps
         {
           framework: detect_framework,
           factories: detect_factories,
           factory_names: detect_factory_names,
           computed_factories: factory_definitions[:computed].nonzero?,
+          fabricators: detect_fabricators,
+          fabricator_names: fabricator_definitions.presence,
+          cucumber: detect_cucumber,
           fixtures: detect_fixtures,
-          fixture_names: detect_fixture_names,
+          fixture_names: fixture_labels[:names],
+          fixture_erb_labels: fixture_labels[:erb],
           system_tests: detect_system_tests,
           test_helpers: detect_test_helpers,
           test_helper_setup: detect_test_helper_setup,
           test_files: test_categories,
           vcr_cassettes: detect_vcr,
           ci_config: detect_ci,
+          ci_steps: ci_steps,
+          ci_steps_dir: ci_steps_dir,
           coverage: detect_coverage,
           factory_traits: detect_factory_traits,
           test_count_by_category: detect_test_count_by_category,
@@ -35,7 +51,7 @@ module RailsAiContext
       private
 
       def detect_framework
-        RailsAiContext::TestFramework.for(root)
+        RailsAiContext::TestFramework.for(suite_root)
       rescue => e
         RailsAiContext.debug_fail(e, "unknown", label: "detect_framework")
       end
@@ -45,7 +61,7 @@ module RailsAiContext
       # answers the other way.
       def first_dir_with(glob, *rels)
         rels.each do |rel|
-          dir = File.join(root, rel)
+          dir = File.join(suite_root, rel)
           next unless Dir.exist?(dir)
 
           count = Dir.glob(File.join(dir, "**", glob)).size
@@ -55,25 +71,180 @@ module RailsAiContext
       end
 
       def detect_factories
-        first_dir_with("*.rb", "spec/factories", "test/factories")
+        locations_with_count(factory_sources)
+      end
+
+      # factory_bot's definition_file_paths: each is loaded as `path.rb` and
+      # as a directory.
+      FACTORY_PATHS = %w[factories test/factories spec/factories].freeze
+      FABRICATOR_PATHS = %w[test/fabricators spec/fabricators].freeze
+      UNREAD_FACTORY_PATH = "a path a test helper builds at run time (not read)"
+
+      # [location, files] for every place factory_bot loads definitions
+      # from, each pack's spec/factories and test/factories included as
+      # packs-rails adds them.
+      def factory_sources
+        @factory_sources ||= factory_definition_paths.flat_map do |rel|
+          next [ [ UNREAD_FACTORY_PATH, [] ] ] if rel.equal?(UNREAD_FACTORY_PATH)
+
+          single = app_files("#{rel}.rb")
+          files = app_files(File.join(rel, "**", "*.rb"))
+          [ ([ "#{rel}.rb", single ] if single.any?), ([ rel, files ] if files.any?) ].compact
+        end
+      end
+
+      # The paths factory_bot loads: factory_bot_rails finds the defaults before any
+      # helper runs, and a helper's writes count only once find_definitions (adds)
+      # or reload (replaces) runs after them.
+      def factory_definition_paths
+        paths = defaults = FACTORY_PATHS + pack_factory_paths
+        loaded = defaults if RailsAiContext::GemLock.for(root).present?("factory_bot_rails")
+        helper_paths.flat_map { |path| Array(helper_walk(path)&.dig(:definition_paths)) }.each do |event|
+          case event[:load]
+          when :find_definitions then loaded = Array(loaded) + paths
+          when :reload then loaded = paths
+          else
+            found = event[:paths].map { |rel| Pathname.new(rel).cleanpath.to_s }.reject { |rel| RailsAiContext::SafePath.traversal?(rel) }
+            found << UNREAD_FACTORY_PATH if event[:unread]
+            paths = event[:replace] ? found : paths + found
+          end
+        end
+        (loaded || defaults).uniq
+      end
+
+      # ponytail: packs-specification's default pack_paths; a packs.yml that
+      # sets its own pack_paths is not read.
+      def pack_factory_paths
+        Dir.glob(File.join(suite_root, "packs", "{*,*/*}", "package.yml")).sort.flat_map do |manifest|
+          pack = File.dirname(manifest)
+          next [] if Dir.glob(File.join(pack, "*.gemspec")).any?
+
+          rel = pack.delete_prefix("#{suite_root}/")
+          [ File.join(rel, "spec/factories"), File.join(rel, "test/factories") ]
+        end
+      end
+
+      def fabricator_sources
+        @fabricator_sources ||= FABRICATOR_PATHS.filter_map do |rel|
+          files = app_files(File.join(rel, "**", "*.rb"))
+          [ rel, files ] if files.any?
+        end
+      end
+
+      def detect_fabricators
+        locations_with_count(fabricator_sources)
+      end
+
+      def fabricator_definitions
+        fabricator_sources.flat_map(&:last).each_with_object({}) do |path, names|
+          found = SourceIntrospector.walk(path, { fabricators: -> { Listeners::GenericMacroListener.new(:Fabricator) } })[:fabricators]
+          named = found.map { |hit| hit[:args].first.to_s }.reject(&:empty?)
+          names[path.delete_prefix("#{suite_root}/")] = named if named.any?
+        end
+      end
+
+      def detect_cucumber
+        features = app_files("features/**/*.feature")
+        return nil if features.empty?
+
+        { location: "features", count: features.size, step_definitions: app_files("features/step_definitions/**/*.rb").size }
+      end
+
+      # A path a helper builds at run time has no files to count, so the count covers only the paths read.
+      def locations_with_count(sources)
+        return nil if sources.empty?
+
+        read = sources.reject { |location, _| location.equal?(UNREAD_FACTORY_PATH) }
+        found = { location: sources.map(&:first).join(", "), count: (read.sum { |_, files| files.size } if read.any?) }
+        read.size < sources.size ? found.merge(unread: true) : found
+      end
+
+      # The files a glob under the suite root matches, sorted, leaving out any whose
+      # real path leaves the app or names a sensitive file. A count (`read: false`)
+      # keeps a sensitive-named file that sits where it is listed, since it opens nothing.
+      # A directory is resolved once for all its files; only a linked file needs its own realpath.
+      def app_files(pattern, read: true)
+        real_root = (@real_root ||= File.realpath(suite_root))
+        real_dirs = {}
+        Dir.glob(File.join(suite_root, pattern)).sort.select do |path|
+          real = if File.lstat(path).symlink?
+            File.realpath(path)
+          else
+            dir = File.dirname(path)
+            File.join(real_dirs[dir] ||= File.realpath(dir), File.basename(path))
+          end
+          relative = real.delete_prefix("#{real_root}/")
+          linked = relative != path.delete_prefix("#{suite_root}/")
+          File.file?(real) && RailsAiContext::SafePath.contained?(real, real_root) &&
+            !((read || linked) && RailsAiContext::SafePath.sensitive?(relative))
+        rescue SystemCallError
+          false
+        end
       end
 
       # The YAML fixture sets Rails loads, and apart from them the other files
       # a fixtures directory holds for file_fixture: an app can keep one YAML file
       # beside hundreds of JSON, XML and binary ones.
       def detect_fixtures
-        found = first_dir_with("*.yml", "spec/fixtures", "test/fixtures") or return nil
+        rows = fixture_dirs.map { |rel| [ rel, app_files(File.join(rel, "**", "*"), read: false) ] }
+        return nil if rows.empty?
 
-        dir = File.join(root, found[:location])
-        others = Dir.glob(File.join(dir, "**", "*")).count { |path| File.file?(path) && File.extname(path) != ".yml" }
+        sets = rows.sum { |_, files| files.count { |path| File.extname(path) == ".yml" } }
+        others = rows.sum { |_, files| files.count { |path| File.extname(path) != ".yml" } }
+        locations = rows.map(&:first)
+        found = { location: locations.join(", "), locations: locations, count: sets }
         others.positive? ? found.merge(other_files: others) : found
       end
 
+      DEFAULT_FIXTURE_DIRS = %w[spec/fixtures test/fixtures].freeze
+
+      # The first default directory that holds a set (an app with both reports
+      # one, as for factories), then each directory a test helper adds to
+      # fixture_paths that holds one and stays inside the app.
+      def fixture_dirs
+        @fixture_dirs ||= begin
+          real_root = File.realpath(suite_root)
+          writes = helper_paths
+            .to_h { |path| [ path, Array(helper_walk(path)&.dig(:fixture_paths)) ] }
+          configured = writes.values.flatten.grep(String)
+          defaults = DEFAULT_FIXTURE_DIRS.reject { |rel| rel == "spec/fixtures" && rspec_fixture_paths_known?(writes) }
+          candidates = [ defaults.find { |rel| fixture_sets?(rel, real_root) } ] +
+                       configured.map { |rel| Pathname.new(rel).cleanpath.to_s }
+          candidates.compact.uniq.select { |rel| fixture_sets?(rel, real_root) }
+        end
+      end
+
+      # rspec-rails gives fixture_paths no default, so an RSpec suite loads only the
+      # directories its helpers name; spec/fixtures stays only when a write under spec/ is unreadable.
+      def rspec_fixture_paths_known?(writes)
+        spec_dir = File.join(suite_root, "spec/")
+        %w[spec/rails_helper.rb spec/spec_helper.rb].any? { |rel| File.file?(File.join(suite_root, rel)) } &&
+          writes.none? { |path, found| path.start_with?(spec_dir) && found.include?(:unread) }
+      end
+
+      def helper_paths
+        HELPER_FILES.map { |rel| File.join(suite_root, rel) } + support_files
+      end
+
+      def support_files
+        @support_files ||= HELPER_DIRS.flat_map { |rel| Dir.glob(File.join(suite_root, rel, "**", "*.rb")).sort }
+      end
+
+      def fixture_sets?(rel, real_root)
+        return false if RailsAiContext::SafePath.traversal?(rel)
+
+        real = File.realpath(File.join(suite_root, rel))
+        RailsAiContext::SafePath.contained?(real, real_root) && File.directory?(real) &&
+          Dir.glob(File.join(real, "**", "*.yml")).any?
+      rescue SystemCallError
+        false
+      end
+
       # Both bases are summed: an app that keeps system tests under spec/ and
       # test/ has both, and reporting one hid the other.
       def detect_system_tests
         rows = %w[spec/system test/system].filter_map do |rel|
-          dir = File.join(root, rel)
+          dir = File.join(suite_root, rel)
           next unless Dir.exist?(dir)
 
           count = Dir.glob(File.join(dir, "**/#{TEST_FILE_GLOB}")).size
@@ -84,16 +255,12 @@ module RailsAiContext
         { location: rows.map(&:first).join(", "), count: rows.sum(&:last) }
       end
 
-      def detect_test_helpers
-        dirs = [
-          File.join(root, "spec/support"),
-          File.join(root, "test/helpers")
-        ]
+      # Where suites keep helper modules. test/helpers is not one: Rails runs
+      # it as a test folder for helper tests.
+      HELPER_DIRS = %w[spec/support test/support test/test_helpers].freeze
 
-        dirs.filter_map do |dir|
-          next unless Dir.exist?(dir)
-          Dir.glob(File.join(dir, "**/*.rb")).map { |f| f.sub("#{root}/", "") }
-        end.flatten.sort
+      def detect_test_helpers
+        HELPER_DIRS.flat_map { |rel| Dir.glob(File.join(suite_root, rel, "**/*.rb")) }.map { |f| f.sub("#{suite_root}/", "") }.sort
       end
 
       def detect_factory_names
@@ -103,87 +270,135 @@ module RailsAiContext
       # One walk per factory file for both the factories and their traits.
       # A factory whose name is computed (`factory :"#{model}_comment"` in a
       # loop, as Consul writes) has no name to list, so it is counted apart.
-      # The first factory directory that has any factory wins.
       def factory_definitions
         @factory_definitions ||= begin
-          found = { names: nil, traits: nil, computed: 0 }
-          %w[spec/factories test/factories].each do |dir_rel|
-            dir = File.join(root, dir_rel)
-            next unless Dir.exist?(dir)
-
-            names = {}
-            traits = {}
-            computed = 0
-            Dir.glob(File.join(dir, "**/*.rb")).each do |path|
-              ast_data = SourceIntrospector.walk(path, {
-                factories: -> { Listeners::GenericMacroListener.new(:factory) },
-                traits: -> { Listeners::GenericMacroListener.new(:trait) }
-              })
-              named = ast_data[:factories].map { |hit| hit[:args].first.to_s }
-              computed += named.count(&:empty?)
-              named = named.reject(&:empty?)
-              trait_names = ast_data[:traits].map { |hit| hit[:args].first.to_s }.reject(&:empty?)
-              names[path.sub("#{root}/", "")] = named if named.any?
-              traits[File.basename(path)] = trait_names if trait_names.any?
-            end
-            next if names.empty? && traits.empty? && computed.zero?
-
-            found = { names: names.presence, traits: traits.presence, computed: computed }
-            break
+          names = {}
+          traits = {}
+          computed = 0
+          factory_sources.flat_map(&:last).each do |path|
+            ast_data = SourceIntrospector.walk(path, {
+              factories: -> { Listeners::GenericMacroListener.new(:factory) },
+              traits: -> { Listeners::GenericMacroListener.new(:trait) }
+            })
+            named = ast_data[:factories].map { |hit| hit[:args].first.to_s }
+            computed += named.count(&:empty?)
+            named = named.reject(&:empty?)
+            trait_names = ast_data[:traits].map { |hit| hit[:args].first.to_s }.reject(&:empty?)
+            names[path.sub("#{suite_root}/", "")] = named if named.any?
+            traits[File.basename(path)] = trait_names if trait_names.any?
           end
-          found
+          { names: names.presence, traits: traits.presence, computed: computed }
         end
       end
 
-      def detect_fixture_names
-        %w[spec/fixtures test/fixtures].each do |dir_rel|
-          dir = File.join(root, dir_rel)
-          next unless Dir.exist?(dir)
-
+      # Each set named as Rails names it, by its path under its directory,
+      # with the labels ActiveRecord loads. A file that does not read as YAML
+      # still gives the labels its top-level keys spell. A label ERB computes
+      # names no row we can write, so it is kept apart, shown as ERB.
+      def fixture_labels
+        @fixture_labels ||= begin
           names = {}
-          Dir.glob(File.join(dir, "**/*.yml")).each do |path|
-            # The set's name, as Rails reads it: its path under the directory.
-            file = path.delete_prefix("#{dir}/").delete_suffix(".yml")
+          erb = {}
+          read_fixture_labels(names, erb)
+          { names: names.presence, erb: erb.presence }
+        end
+      end
+
+      def read_fixture_labels(names, erb)
+        fixture_dirs.each do |rel|
+          dir = File.join(suite_root, rel)
+          app_files(File.join(rel, "**", "*.yml")).each do |path|
+            set = path.delete_prefix("#{dir}/").delete_suffix(".yml")
+            next if names.key?(set)
+
             content = RailsAiContext::SafeFile.read(path) or next
-            keys = content.scan(/^(\w+):/).flatten.select { |key| RailsAiContext::FixtureKeys.name?(key) }
-            names[file] = keys if keys.any?
+            labels = RailsAiContext::FixtureKeys.parse(content)&.keys ||
+                     content.scan(/^(\w+):/).flatten.select { |key| RailsAiContext::FixtureKeys.name?(key) }
+            computed, named = labels.partition { |label| RailsAiContext::ConfigYaml.marked?(label) }
+            names[set] = named if labels.any?
+            erb[set] = computed.map { |label| RailsAiContext::ConfigYaml.shown(label) } if computed.any?
           end
-          return names if names.any?
         end
-        nil
       end
 
+      # Calls that configure every test or every system test, shown as written.
+      SETUP_MACROS = %i[parallelize fixtures driven_by].freeze
+
+      HELPER_FILES = %w[spec/rails_helper.rb spec/spec_helper.rb test/test_helper.rb].freeze
+
       def detect_test_helper_setup
-        helpers = %w[spec/rails_helper.rb spec/spec_helper.rb test/test_helper.rb].map { |rel| File.join(root, rel) }
+        helpers = (HELPER_FILES + %w[test/application_system_test_case.rb]).map { |rel| File.join(suite_root, rel) }
         # Apps also configure helpers in support files (Errbit's spec/support/devise.rb). A bare
         # include there is usually a support module's own mixin, so only config.include counts.
-        support = %w[spec/support test/support].flat_map { |rel| Dir.glob(File.join(root, rel, "**", "*.rb")).sort }
+        support = support_files
 
         setup = []
+        calls = []
         (helpers + support).each do |path|
-          next unless File.file?(path)
-          ast = SourceIntrospector.walk(path, {
-            bare:    -> { Listeners::GenericMacroListener.new(:include) },
-            chained: -> { Listeners::ChainedCallListener.new(:include, receiver: :config) }
-          })
+          ast = helper_walk(path) or next
           hits = helpers.include?(path) ? ast[:bare] + ast[:chained] : ast[:chained]
           # `config.include Helpers, :js` scopes Helpers to tagged examples; the tag is no helper.
           hits.each { |hit| setup.concat(hit[:values].map(&:to_s).grep(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/)) }
+          source = AstCache.parse(path).source
+          ast[:setup].each { |hit| calls << source.slice(hit[:offset], hit[:end_offset] - hit[:offset]).squish }
         end
-        setup.uniq
+        (setup + calls).uniq
+      end
+
+      # One walk per helper file serves every reader of it.
+      def helper_walk(path)
+        @helper_walks ||= {}
+        return @helper_walks[path] if @helper_walks.key?(path)
+
+        @helper_walks[path] = File.file?(path) ? SourceIntrospector.walk(path, {
+          bare:          -> { Listeners::GenericMacroListener.new(:include) },
+          chained:       -> { Listeners::ChainedCallListener.new(:include, receiver: :config) },
+          setup:         -> { Listeners::GenericMacroListener.new(*SETUP_MACROS) },
+          fixture_paths: -> { Listeners::FixturePathsListener.new(file: path.delete_prefix("#{suite_root}/")) },
+          definition_paths: -> { Listeners::DefinitionFilePathsListener.new(file: path.delete_prefix("#{suite_root}/")) },
+          cleaner:       -> { Listeners::ConfigAssignmentListener.new(:DatabaseCleaner) }
+        }) : nil
       end
 
       def detect_vcr
         first_dir_with("*.yml", "spec/cassettes", "spec/vcr_cassettes", "test/cassettes", "test/vcr_cassettes")
       end
 
+      # A dummy's own config/ci.rb and its engine's .github are both the project's CI.
       def detect_ci
-        configs = []
-        configs << "github_actions" if Dir.exist?(File.join(root, ".github/workflows"))
-        configs << "circleci" if File.exist?(File.join(root, ".circleci/config.yml"))
-        configs << "gitlab_ci" if File.exist?(File.join(root, ".gitlab-ci.yml"))
-        configs << "travis" if File.exist?(File.join(root, ".travis.yml"))
-        configs
+        ci_roots.flat_map do |dir|
+          configs = []
+          configs << "rails_ci" if File.file?(File.join(dir, RAILS_CI))
+          configs << "github_actions" if Dir.exist?(File.join(dir, ".github/workflows"))
+          configs << "circleci" if File.exist?(File.join(dir, ".circleci/config.yml"))
+          configs << "gitlab_ci" if File.exist?(File.join(dir, ".gitlab-ci.yml"))
+          configs << "travis" if File.exist?(File.join(dir, ".travis.yml"))
+          configs << "buildkite" if Dir.exist?(File.join(dir, ".buildkite")) || Dir.glob(File.join(dir, "buildkite.{yml,yaml,json}")).any?
+          configs << "jenkins" if File.file?(File.join(dir, "Jenkinsfile"))
+          configs << "bitbucket_pipelines" if File.file?(File.join(dir, "bitbucket-pipelines.yml"))
+          configs
+        end.uniq
+      end
+
+      def ci_roots
+        [ root, suite_root ].uniq
+      end
+
+      # The steps bin/ci runs, from the `step title, *command` calls of the
+      # CI DSL Rails 8.1 generates, and the directory of config/ci.rb when it is not the suite root.
+      def detect_ci_steps
+        dir, content = ci_roots.lazy.filter_map { |d| (text = RailsAiContext::SafePath.read(RAILS_CI, under: d).first) && [ d, text ] }.first
+        return nil unless content
+
+        # Paths in the answer are under the suite root, which for a test/dummy is the engine's.
+        ci_dir = "#{Pathname.new(PathResolver.root_key(dir)).relative_path_from(Pathname.new(PathResolver.root_key(suite_root)))}/" unless dir == suite_root
+
+        hits = SourceIntrospector.walk_source(content, steps: -> { Listeners::GenericMacroListener.new(:step) })[:steps]
+        steps = hits.filter_map do |hit|
+          title, *command = hit[:values]
+          { name: title, command: command.join(" ") } if title.is_a?(String)
+        end
+        [ steps.presence, ci_dir ]
       end
 
       def detect_coverage
@@ -199,7 +414,7 @@ module RailsAiContext
       def detect_shared_examples
         shared = []
         %w[spec test].each do |base|
-          support_dir = File.join(root, base, "support")
+          support_dir = File.join(suite_root, base, "support")
           next unless Dir.exist?(support_dir)
           Dir.glob(File.join(support_dir, "**/*.rb")).each do |path|
             ast_data = SourceIntrospector.walk(path, {
@@ -208,7 +423,7 @@ module RailsAiContext
             ast_data[:shared].each do |entry|
               name = entry[:args].first&.to_s
               next unless name && !name.empty?
-              shared << { name: name, file: path.sub("#{root}/", "") }
+              shared << { name: name, file: path.sub("#{suite_root}/", "") }
             end
           end
         end
@@ -222,12 +437,8 @@ module RailsAiContext
         # complete signal; the unsuffixed name is the pre-2.0 single gem.
         if RailsAiContext::GemLock.for(root).any?("database_cleaner", "database_cleaner-core")
           strategy = nil
-          %w[spec/rails_helper.rb spec/spec_helper.rb test/test_helper.rb].each do |helper|
-            path = File.join(root, helper)
-            next unless File.exist?(path)
-            ast = SourceIntrospector.walk(path, {
-              cleaner: -> { Listeners::ConfigAssignmentListener.new(:DatabaseCleaner) }
-            })
+          HELPER_FILES.each do |helper|
+            ast = helper_walk(File.join(suite_root, helper)) or next
             hit = ast[:cleaner].find { |h| h[:assignment] && h[:path] == [ :strategy ] }
             strategy = hit[:value].to_s if hit
           end
@@ -261,7 +472,7 @@ module RailsAiContext
         rows = Hash.new { |h, k| h[k] = [] }
 
         %w[spec test].each do |base|
-          base_dir = File.join(root, base)
+          base_dir = File.join(suite_root, base)
           next unless Dir.exist?(base_dir)
 
           Dir.children(base_dir).sort.each do |entry|

data/lib/rails_ai_context/introspectors/turbo_introspector.rb

@@ -9,7 +9,7 @@ module RailsAiContext
 
       MODEL_BROADCAST_MACROS = %w[broadcasts broadcasts_to broadcasts_refreshes broadcasts_refreshes_to].freeze
       BROADCAST_CALL = /\Abroadcast_\w+_to\z/
-      BROADCAST_KINDS = %w[app/controllers app/models app/services app/jobs app/workers app/channels].freeze
+      BROADCAST_KINDS = %w[app/controllers app/services app/jobs app/workers app/channels].freeze
 
       # A mention of these helpers anywhere in a controller is the signal,
       # whether called, referenced or guarded. Vocabulary, not structure, so
@@ -90,7 +90,7 @@ module RailsAiContext
       # The views root a path was found under, for the containment check that
       # keeps a symlink escaping the tree out of the answer.
       def views_root_of(path)
-        PathResolver.view_dirs(root).find { |dir| path.start_with?("#{dir}/") } || views_dir
+        RailsAiContext::ViewFile.root_for(path, PathResolver.view_dirs(root)) || views_dir
       end
 
       # Views are not Ruby, so they are read line by line. Files are yielded
@@ -187,10 +187,15 @@ module RailsAiContext
       def scan_broadcasts
         models = []
         explicit = []
-        BROADCAST_KINDS.each do |kind|
-          SourceScan.each(root, kind: kind, skip_concerns: false) do |record|
+        seen = Set.new
+        # A model outside app/models also sits under another kind's directory.
+        [ :models, *BROADCAST_KINDS ].each do |kind|
+          records = kind == :models ? model_sources(skip_concerns: false) : SourceScan.each(root, kind: kind, skip_concerns: false)
+          records.each do |record|
+            next unless seen.add?(record.path)
+
             walked = walk_broadcasts(record.source)
-            models.concat(model_entries(record, walked[:macros])) if kind == "app/models"
+            models.concat(model_entries(record, walked[:macros])) if kind == :models
             explicit.concat(explicit_entries(record, walked[:calls]))
           end
         end

data/lib/rails_ai_context/introspectors/view_introspector.rb

@@ -17,8 +17,7 @@ module RailsAiContext
           view_components: extract_view_components,
           template_engines: detect_template_engines,
           form_builders_detected: detect_form_builders,
-          component_usage: detect_component_usage,
-          conditional_layouts: detect_conditional_layouts
+          component_usage: detect_component_usage
         }
       end
 
@@ -127,9 +126,12 @@ module RailsAiContext
         return [] unless Dir.exist?(dir)
 
         Dir.glob(File.join(dir, "**/*.rb")).filter_map do |path|
+          source = RailsAiContext::SafeFile.read(path)
+          next if source && !HelperNames.view_helper?(source, path, dir)
+
           relative = path.sub("#{dir}/", "")
           module_name = relative.sub(/\.rb\z/, "").camelize
-          ast_data = SourceIntrospector.walk(path, { methods: Listeners::MethodsListener })
+          ast_data = SourceIntrospector.walk(path, { methods: Listeners::MethodsListener }, source: source)
           methods = ActionResolver.own_methods(ast_data[:methods], module_name).map { |m| m[:name] }
           {
             file: relative,
@@ -202,43 +204,6 @@ module RailsAiContext
       rescue => e
         RailsAiContext.debug_fail(e, [], label: "detect_component_usage")
       end
-
-      def detect_conditional_layouts
-        layouts = []
-        controllers_dir = File.join(app.root, "app", "controllers")
-        return layouts unless Dir.exist?(controllers_dir)
-
-        Dir.glob(File.join(controllers_dir, "**", "*.rb")).each do |path|
-          ast_data = SourceIntrospector.walk(path, {
-            layout_calls: -> { Listeners::GenericMacroListener.new(:layout) }
-          })
-
-          ast_data[:layout_calls].each do |macro|
-            layout_name = macro[:args]&.first&.to_s
-            # Also check options for string-based layout names
-            layout_name ||= macro[:options].values.first&.to_s if macro[:options]&.any?
-            next unless layout_name
-
-            entry = { layout: layout_name, controller: File.basename(path, ".rb").camelize }
-            opts = macro[:options] || {}
-            entry[:only] = Array(opts[:only]).map(&:to_s) if opts[:only]
-            entry[:except] = Array(opts[:except]).map(&:to_s) if opts[:except]
-
-            # Build condition string from options for backward compat
-            condition_parts = []
-            condition_parts << "only: #{opts[:only].inspect}" if opts[:only]
-            condition_parts << "except: #{opts[:except].inspect}" if opts[:except]
-            entry[:condition] = condition_parts.join(", ") if condition_parts.any?
-
-            layouts << entry
-          end
-        rescue => e
-          RailsAiContext.debug_fail(e, label: "detect_conditional_layouts")
-        end
-        layouts
-      rescue => e
-        RailsAiContext.debug_fail(e, [], label: "detect_conditional_layouts")
-      end
     end
   end
 end

data/lib/rails_ai_context/introspectors/view_template_introspector.rb

@@ -363,6 +363,9 @@ module RailsAiContext
       # A partial or template name: a path, never text with spaces or quotes in it.
       PARTIAL_NAME = %r{\A[\w./-]+\z}
       RENDER_NAMED = /(?:\b(?:partial|template)\s*:|:(?:partial|template)\s*=>)\s*["']([^"']+)["']/
+      # `render @posts`, `render(post)`, `render @posts, cached: true`: a bare record or collection, or a
+      # chain on one (`@post.comments.recent`), matched against "render <args>"; RenderedRecord reads the chain.
+      IMPLICIT_RENDER = /\Arender\s*\(?\s*@?((?:[a-z_]\w*\.)*[a-z_]\w*)\s*(?:[,)]|\s(?:if|unless)\b|-?\s*\z)/
 
       def extract_partial_refs(content)
         refs = []
@@ -372,22 +375,21 @@ module RailsAiContext
           named = [ args[RENDER_POSITIONAL, 2], *top_level(args).scan(RENDER_NAMED).flatten ].compact
           # An interpolated name is decided at runtime, not a partial on disk.
           refs.concat(named.select { |name| name.match?(PARTIAL_NAME) })
-        end
-        # render @collection
-        content.scan(/render\s+@(\w+)/).each { |m| refs << m[0] }
-        # render article / render(article) - Rails 7+ bare local-variable/object
-        # render (the scaffold default: `render @articles.each { |article| render article }`).
-        # The negative lookahead excludes keyword-argument hashes like
-        # `render json: ...` / `render partial: ...`, where a colon immediately
-        # follows the identifier instead of a statement boundary.
-        content.scan(/\brender[\s(]+([a-z_]\w*)\b(?!\s*:)/).each do |m|
-          refs << m[0] unless RENDER_KEYWORD_ARGS.include?(m[0])
+          chain = self.class.render_line(args)[IMPLICIT_RENDER, 1] if named.empty?
+          model, collection = chain && !RENDER_KEYWORD_ARGS.include?(chain) && RenderedRecord.resolve(chain, root, @rendered_models ||= {})
+          # The records' model names the partial; `replies` with class_name "Comment" renders comments/_comment.
+          refs << (collection ? model.pluralize : model) if model
         end
         # Phlex: render ComponentName.new(...) or render(ComponentName.new(...))
         content.scan(/render[\s(]+([A-Z]\w+(?:::\w+)*)\.new/).each { |m| refs << m[0] }
         refs.uniq
       end
 
+      # A render call's ERB-free arguments on one line, as IMPLICIT_RENDER reads them.
+      def self.render_line(args)
+        "render #{args.split("%>", 2).first.gsub(/\s+/, " ").strip}"
+      end
+
       # Each render call as [offset, argument text]: its balanced parentheses,
       # or the rest of the line and every line a trailing comma continues onto.
       def self.render_calls(content)