rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/database_yml.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module RailsAiContext
+  # config/database.yml read without booting: YAML, so anchors, merge keys and
+  # comments follow the file format itself, and ERB never runs.
+  module DatabaseYml
+    ERB_SENTINEL = "__rails_ai_context_erb__"
+    # `ENV["X"].presence || "mysql2"`: the literal is what runs with the variable unset.
+    ERB_DEFAULT = /\|\|\s*(["'])([\w.-]+)\1\s*\z/
+    # ActiveRecord.protocol_adapters' defaults.
+    URL_SCHEME_ADAPTERS = { "postgres" => "postgresql", "mysql" => "mysql2", "sqlite" => "sqlite3" }.freeze
+
+    module_function
+
+    # The running environment's entry, or nil when the file is missing or unreadable.
+    def env(root)
+      data = file(root)
+      data[RailsAiContext.environment_name] if data
+    end
+
+    # Every environment by name. Every database question routes here, so a run reads the file once.
+    def file(root)
+      RailsAiContext::RunCache.fetch([ :database_yml, root.to_s ]) { read_file(root) }
+    end
+
+    def read_file(root)
+      path = File.join(root.to_s, "config/database.yml")
+      return nil unless File.exist?(path)
+
+      content = RailsAiContext::SafeFile.read(path)
+      return nil unless content
+
+      data = YAML.safe_load(neutralize_erb(content), aliases: true, permitted_classes: [ Symbol ])
+      data if data.is_a?(Hash)
+    rescue => e
+      RailsAiContext.debug_fail(e, nil, label: "database_yml")
+    end
+
+    # Each database by name, in the file's order. An env whose values are all Hashes names one database per key.
+    def databases(root)
+      databases_in(env(root))
+    end
+
+    def databases_in(config)
+      return {} unless config.is_a?(Hash) && config.any?
+
+      config.values.all?(Hash) ? config : { "primary" => config }
+    end
+
+    # Rails' rule: "primary", else the first database.
+    def primary_name(root)
+      primary_name_in(databases(root))
+    end
+
+    def primary_name_in(found)
+      found.key?("primary") ? "primary" : found.keys.first
+    end
+
+    # The databases other than the primary that Rails dumps and migrates:
+    # HashConfig#database_tasks? skips a replica and database_tasks: false.
+    def task_secondaries(root)
+      databases(root).except(primary_name(root)).select { |_, entry| !entry["replica"] && entry.fetch("database_tasks", true) }
+    end
+
+    # The primary database's settings.
+    def primary(root)
+      databases(root)[primary_name(root)]
+    end
+
+    # The named database's settings in the running environment, or nil.
+    def entry(root, name)
+      entry_in(databases(root), name)
+    end
+
+    # [environment, settings] from the first other environment that configures the database,
+    # the one whose tasks wrote its dump; nil when none does.
+    def elsewhere(root, name)
+      data = file(root)
+      return nil unless data
+
+      # A key with no config/environments file holds an anchor (`default: &default`), not an environment.
+      declared = Dir.glob(File.join(root.to_s, "config/environments/*.rb")).map { |path| File.basename(path, ".rb") }
+      data.each do |env_name, config|
+        next if env_name == RailsAiContext.environment_name
+        next if declared.any? && !declared.include?(env_name)
+
+        found = entry_in(databases_in(config), name)
+        return [ env_name, found ] if found.is_a?(Hash)
+      end
+      nil
+    end
+
+    def entry_in(found, name)
+      found[name] || (found[primary_name_in(found)] if name == "primary")
+    end
+
+    # Rails' DatabaseConfigurations: an entry's own url wins over its keys, and an entry
+    # without one takes <NAME>_DATABASE_URL, or DATABASE_URL for the primary.
+    def url_adapter(name, own_url)
+      url = own_url.nil? ? ENV["#{name.upcase}_DATABASE_URL"] || (ENV["DATABASE_URL"] if name == "primary") : own_url.to_s
+      return nil if url.to_s.empty? || computed?(url)
+
+      scheme = url[/\A([a-z][a-z0-9+.-]*):/i, 1]&.tr("-", "_")
+      scheme && URL_SCHEME_ADAPTERS.fetch(scheme, scheme)
+    end
+
+    # [adapter, from_default]: the URL's scheme wins, then the entry's adapter. An ERB-computed
+    # value is unknown unless it is one tag carrying its own literal default.
+    def adapter(name, entry)
+      entry = {} unless entry.is_a?(Hash)
+      from_url = url_adapter(name.to_s, entry["url"])
+      return [ from_url, false ] if from_url
+
+      text = entry["adapter"]&.to_s
+      return [ text, false ] unless computed?(text)
+      return [ nil, false ] unless text.start_with?(ERB_SENTINEL) && text.scan(ERB_SENTINEL).size == 1
+
+      literal = text.delete_prefix(ERB_SENTINEL)
+      literal.empty? ? [ nil, false ] : [ literal, true ]
+    end
+
+    # An output tag becomes an unknown marker, other tags go, and both keep their
+    # newlines so the rest of the file parses at its written indentation.
+    def neutralize_erb(content)
+      content.gsub(RailsAiContext::ErbSource::TAG) do |tag|
+        (tag.start_with?("<%=") ? ERB_SENTINEL + Regexp.last_match(1).to_s[ERB_DEFAULT, 2].to_s : "") + ("\n" * tag.count("\n"))
+      end
+    end
+
+    def computed?(value)
+      value.to_s.include?(ERB_SENTINEL)
+    end
+  end
+end

data/lib/rails_ai_context/doctor.rb

@@ -97,14 +97,14 @@ module RailsAiContext
     # ── Existence checks ──────────────────────────────────────────────
 
     def check_schema
-      schema_path = File.join(app.root, "db/schema.rb")
-      structure_path = File.join(app.root, "db/structure.sql")
-      if File.exist?(schema_path)
-        lines = File.readlines(schema_path).size
-        Check.new(name: "Schema", status: :pass, message: "db/schema.rb found (#{count_phrase(lines, "line")})", fix: nil)
-      elsif File.exist?(structure_path)
-        size = (File.size(structure_path) / 1024.0).round(1)
-        Check.new(name: "Schema", status: :pass, message: "db/structure.sql found (#{size}KB)", fix: nil)
+      format, path = RailsAiContext::Introspectors::SchemaDumpPath.present(app.root)
+      shown = path.to_s.delete_prefix("#{app.root.to_s.chomp('/')}/")
+      if format == :ruby
+        lines = File.readlines(path).size
+        Check.new(name: "Schema", status: :pass, message: "#{shown} found (#{count_phrase(lines, "line")})", fix: nil)
+      elsif format == :sql
+        size = (File.size(path) / 1024.0).round(1)
+        Check.new(name: "Schema", status: :pass, message: "#{shown} found (#{size}KB)", fix: nil)
       else
         Check.new(name: "Schema", status: :warn, message: "No schema file found", fix: "Run `rails db:schema:dump`")
       end
@@ -113,7 +113,7 @@ module RailsAiContext
     def check_pending_migrations
       return nil unless defined?(ActiveRecord::Base)
 
-      pending = RailsAiContext::PendingMigrations.live(RailsAiContext::PendingMigrations.migrate_dir_for(app.root))
+      pending = RailsAiContext::PendingMigrations.live(RailsAiContext::PendingMigrations.migrate_dirs_for(app.root))
       return nil unless pending
 
       if pending.empty?
@@ -144,11 +144,11 @@ module RailsAiContext
     end
 
     def check_gems
-      lock_path = File.join(app.root, "Gemfile.lock")
-      if File.exist?(lock_path)
-        Check.new(name: "Gems", status: :pass, message: "Gemfile.lock found", fix: nil)
+      lockfile = GemLock.lockfile_name(app.root)
+      if File.exist?(File.join(app.root, lockfile))
+        Check.new(name: "Gems", status: :pass, message: "#{lockfile} found", fix: nil)
       else
-        Check.new(name: "Gems", status: :warn, message: "Gemfile.lock not found", fix: "Run `bundle install`")
+        Check.new(name: "Gems", status: :warn, message: "#{lockfile} not found", fix: "Run `bundle install`")
       end
     end
 
@@ -182,9 +182,8 @@ module RailsAiContext
     end
 
     def check_migrations
-      migrate_dir = File.join(app.root, "db/migrate")
-      if Dir.exist?(migrate_dir) && Dir.glob(File.join(migrate_dir, "*.rb")).any?
-        count = Dir.glob(File.join(migrate_dir, "*.rb")).size
+      count = RailsAiContext::PendingMigrations.migration_files(RailsAiContext::PendingMigrations.migrate_dirs_for(app.root), root: app.root).size
+      if count.positive?
         Check.new(name: "Migrations", status: :pass, message: count_phrase(count, "migration file"), fix: nil)
       else
         Check.new(name: "Migrations", status: :warn, message: "No migrations", fix: nil)
@@ -438,13 +437,16 @@ module RailsAiContext
       introspector = RailsAiContext::Introspector.new(app)
       failures = []
 
-      config.introspectors.each do |name|
-        result = introspector.send(:resolve_introspector, name).call
-        failures << [ name.to_s, result[:error].to_s ] if result.is_a?(Hash) && result[:error]
-      rescue StandardError, ScriptError => e
-        # ScriptError included: a syntax-broken app file must cost one
-        # introspector, not the diagnosis the user ran doctor for.
-        failures << [ name.to_s, "#{e.class}: #{e.message}" ]
+      # One run, as introspection has: the file lists and stats each introspector asks for are shared.
+      RunCache.around do
+        config.introspectors.each do |name|
+          result = introspector.send(:resolve_introspector, name).call
+          failures << [ name.to_s, result[:error].to_s ] if result.is_a?(Hash) && result[:error]
+        rescue StandardError, ScriptError => e
+          # ScriptError included: a syntax-broken app file must cost one
+          # introspector, not the diagnosis the user ran doctor for.
+          failures << [ name.to_s, "#{e.class}: #{e.message}" ]
+        end
       end
 
       if failures.empty?
@@ -577,21 +579,15 @@ module RailsAiContext
 
       return Check.new(name: "Secrets in .gitignore", status: :pass, message: "No sensitive files found", fix: nil) if sensitive_files.empty?
 
-      unless File.exist?(gitignore_path)
-        return Check.new(name: "Secrets in .gitignore", status: :fail,
-          message: "No .gitignore found - #{sensitive_files.join(', ')} would be committed to version control",
-          fix: "Create .gitignore with: #{sensitive_files.map { |f| "`#{f}`" }.join(', ')}")
-      end
-
-      gitignore = File.read(gitignore_path)
-      exposed = sensitive_files.reject { |file| gitignore_covers?(gitignore, file) }
+      gitignore = File.read(gitignore_path) if File.exist?(gitignore_path)
+      exposed = gitignore ? sensitive_files.reject { |file| gitignore_covers?(gitignore, file) } : sensitive_files
       never, others = exposed.partition { |file| NEVER_COMMIT.any? { |pattern| File.fnmatch(pattern, file, File::FNM_PATHNAME | File::FNM_DOTMATCH) } }
 
       if never.any?
-        message = never.map { |file| "#{file} not in .gitignore" }.join("; ")
+        message = gitignore ? never.map { |file| "#{file} not in .gitignore" }.join("; ") : "No .gitignore found - #{never.join(', ')} would be committed"
         message += "; also committed: #{others.join(', ')}" if others.any?
         Check.new(name: "Secrets in .gitignore", status: :fail, message: message,
-          fix: "Add to .gitignore: #{never.map { |file| "`#{file}`" }.join(', ')}")
+          fix: "#{gitignore ? 'Add to .gitignore' : 'Create .gitignore with'}: #{never.map { |file| "`#{file}`" }.join(', ')}")
       elsif others.any?
         Check.new(name: "Secrets in .gitignore", status: :warn,
           message: "Committed, and never read by the tools: #{others.join(', ')}",
@@ -658,10 +654,7 @@ module RailsAiContext
 
     def check_performance_schema_size
       config = RailsAiContext.configuration
-      schema_path = File.join(app.root, "db/schema.rb")
-      structure_path = File.join(app.root, "db/structure.sql")
-
-      path = File.exist?(schema_path) ? schema_path : (File.exist?(structure_path) ? structure_path : nil)
+      _, path = RailsAiContext::Introspectors::SchemaDumpPath.present(app.root)
       return nil unless path
 
       size = File.size(path)

data/lib/rails_ai_context/erb_source.rb

@@ -48,6 +48,46 @@ module RailsAiContext
       source.to_s.gsub(TAG) { "\n" * Regexp.last_match(0).count("\n") }
     end
 
+    # Like without_tags, but an output tag (`<%= %>`) becomes `marker`, so a value
+    # or key it builds reads as computed. A tag alone on its line writes lines we
+    # cannot see, and a marker there would break the YAML around it, unless the
+    # line above opens a value the tag fills. Each marker is numbered, so two keys tags name stay two keys.
+    def with_output_marked(source, marker)
+      source = source.to_s
+      count = 0
+      source.gsub(TAG) do
+        match = Regexp.last_match
+        tag = match[0]
+        next "\n" * tag.count("\n") unless tag.start_with?("<%=") && !lines_written?(source, match.begin(0), match.end(0))
+
+        "#{marker}_#{count += 1}_"
+      end
+    end
+
+    BLOCK_SCALAR = /(?:\A|\s)[|>][-+0-9]*\z/
+    VALUE_OPENER = /:\z/
+    private_constant :BLOCK_SCALAR, :VALUE_OPENER
+
+    def lines_written?(source, from, to)
+      line_start = from.zero? ? 0 : (source.rindex("\n", from - 1) || -1) + 1
+      line_end = source.index("\n", to) || source.size
+      return false unless source[line_start...from].strip.empty? && source[to...line_end].strip.empty?
+
+      above = source[0...line_start].rstrip.lines.last.to_s.rstrip
+      return false if above.match?(BLOCK_SCALAR)
+      return true unless above.match?(VALUE_OPENER)
+
+      # A sibling at the tag's indent below means the tag wrote keys, not the value.
+      below = source[line_end..].to_s.lines.find { |line| !line.strip.empty? }
+      !below.nil? && indent(below) >= from - line_start
+    end
+    private_class_method :lines_written?
+
+    def indent(line)
+      line[/\A */].size
+    end
+    private_class_method :indent
+
     def blank(text)
       text.gsub(/[^\n]/, " ")
     end

data/lib/rails_ai_context/fingerprinter.rb

@@ -6,18 +6,18 @@ module RailsAiContext
   # Computes a SHA256 fingerprint of key application files to detect changes.
   # Used by BaseTool to invalidate cached introspection when files change.
   class Fingerprinter
-    # The root manifests, plus the one file under a watched directory whose
-    # extension WATCHED_EXTENSIONS does not name.
-    WATCHED_FILES = %w[
-      db/structure.sql
+    # The root manifests.
+    WATCHED_FILES = (%w[
       Gemfile
       Gemfile.lock
+      gems.rb
+      gems.locked
       package.json
       tsconfig.json
-    ].freeze
+      config.ru
+    ] + Introspectors::RakeTaskIntrospector::RAKEFILES).freeze
 
-    # The one scope: everything the fingerprint walks is also everything the
-    # watcher watches.
+    # One scope for fingerprint and watcher; app/, test/ and spec/ whole since readers scan any file there.
     WATCHED_DIRS = (%w[
       app/models
       app/controllers
@@ -26,13 +26,14 @@ module RailsAiContext
       app/channels
       app/components
       app/helpers
-      app/services
       app/javascript/controllers
       app/middleware
       config
       db
-      lib/tasks
-    ] + Introspectors::JobIntrospector::JOB_DIRS).freeze
+      lib
+      rakelib
+    ] + Introspectors::ServiceClasses::ROOTS + Introspectors::JobIntrospector::JOB_DIRS + Introspectors::GrapeEndpoints::DIRS +
+      %w[app test spec]).freeze
 
     # The kinds whose homes PathResolver resolves beyond the conventional
     # tree - packs/*, engines/* and configured extras. Derived at compute
@@ -41,12 +42,20 @@ module RailsAiContext
     # prevent.
     RESOLVED_KINDS = (%w[
       app/models app/controllers app/views app/mailers
-      app/channels app/components app/helpers app/services
-    ] + Introspectors::JobIntrospector::JOB_DIRS).freeze
+      app/channels app/components app/helpers
+    ] + Introspectors::ServiceClasses::ROOTS + Introspectors::JobIntrospector::JOB_DIRS).freeze
 
     # The file kinds a change can hide in. One list, so a walk that reports
     # a change and a walk that names it read the same tree.
-    WATCHED_EXTENSIONS = "**/*.{rb,rake,js,ts,erb,haml,slim,yml}"
+    # sql: a structure dump, under whatever name database.yml's schema_dump gives it.
+    # tt: a generator template override under lib/templates.
+    WATCHED_EXTNAMES = %w[.rb .rake .js .ts .erb .haml .slim .yml .sql .tt].freeze
+    WATCHED_EXTENSIONS = "**/*{#{WATCHED_EXTNAMES.join(",")}}"
+
+    # jsbundling and cssbundling rewrite this on every frontend save, and no reader reads it.
+    BUILD_OUTPUT = "/app/assets/builds/"
+    # A test run re-records these; the VCR reader counts them and never opens one.
+    CASSETTES = %r{\A(?:spec|test)/(?:[^/]+/)*(?:vcr_)?cassettes/}
 
     # What a reader holds so it can ask later whether the app moved. Taken
     # before the read it protects: a mark taken after introspection records
@@ -84,9 +93,10 @@ module RailsAiContext
           # File deleted between exist? check and mtime read - skip
         end
 
+        prefix = SafePath.dir_prefix(root)
         watched_dirs(root).each do |full_dir|
-          Dir.glob(File.join(full_dir, WATCHED_EXTENSIONS)).sort.each do |path|
-            digest.update(File.mtime(path).to_f.to_s)
+          watched_files(full_dir).sort.each do |path|
+            digest.update(cassette?(path, prefix) ? path : File.mtime(path).to_f.to_s)
           rescue Errno::ENOENT
             # File deleted between glob and mtime read - skip
           end
@@ -99,11 +109,16 @@ module RailsAiContext
       # the resolvers add for this app (packs, engines, extra_app_paths,
       # concern homes such as app/serializers/concerns).
       def watched_dirs(root)
+        dirs = scope_dirs(root)
+        # A dir under another one is already globbed and watched through it.
+        dirs.reject { |dir| dirs.any? { |other| dir.start_with?("#{other}/") } }
+      end
+
+      def scope_dirs(root)
         conventional = WATCHED_DIRS.map { |dir| File.join(root, dir) }
         resolved = RESOLVED_KINDS.flat_map { |kind| PathResolver.dirs_for(root, kind) }
 
-        (conventional + resolved + ConcernPaths.resolve(root) + stimulus_dirs(root))
-          .uniq.select { |dir| Dir.exist?(dir) }
+        (conventional + resolved + ConcernPaths.resolve(root) + stimulus_dirs(root)).uniq.select { |dir| Dir.exist?(dir) }
       end
 
       # The controller homes the Stimulus introspector reads, so an edit under
@@ -113,17 +128,28 @@ module RailsAiContext
                                            .map { |path, _js_root| File.dirname(path) }.uniq
       end
 
-      # Which watched directories hold a file newer than the given time,
-      # named the way an app author would write them.
+      # Which directories hold a file newer than the given time, each named by
+      # the narrowest scope dir that holds it, the way an app author would write it.
       def changed_since(root, time)
         base = File.expand_path(root.to_s)
-        watched_dirs(base).select { |dir|
-          Dir.glob(File.join(dir, WATCHED_EXTENSIONS)).any? { |path| newer?(path, time) }
-        }.map { |dir| dir.delete_prefix(base + File::SEPARATOR) }
+        named = scope_dirs(base)
+        prefix = SafePath.dir_prefix(base)
+        watched_dirs(base).flat_map { |dir| watched_files(dir).select { |path| !cassette?(path, prefix) && newer?(path, time) } }
+                          .map { |path| named.select { |dir| path.start_with?("#{dir}/") }.max_by(&:size) }
+                          .uniq.map { |dir| dir.delete_prefix(prefix) }
       end
 
       private
 
+      # One walk with an extension filter: a brace glob walks the tree once per extension.
+      def watched_files(dir)
+        Dir.glob(File.join(dir, "**/*")).select { |path| WATCHED_EXTNAMES.include?(File.extname(path)) && !path.include?(BUILD_OUTPUT) }
+      end
+
+      def cassette?(path, prefix)
+        path.delete_prefix(prefix).match?(CASSETTES)
+      end
+
       def newer?(path, time)
         File.mtime(path) > time
       rescue Errno::ENOENT

data/lib/rails_ai_context/fixture_keys.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "date"
+require "digest"
+require "yaml"
+
 module RailsAiContext
   # A fixture file's top-level keys are fixture names, with two exceptions.
   # ActiveRecord drops the shared-attribute anchor the fixtures guide writes as
@@ -7,10 +11,47 @@ module RailsAiContext
   # "No fixture named". Every surface that reads those keys asks here.
   module FixtureKeys
     ANCHOR = "DEFAULTS"
+    CONFIG = "_fixture"
 
+    # A label ERB printed into was computed, so its real names are unknown.
     def self.name?(key)
       key = key.to_s
-      key != ANCHOR && !key.start_with?("_")
+      key != ANCHOR && !key.start_with?("_") && !ConfigYaml.marked?(key)
+    end
+
+    # label => attributes, or nil when not fixtures; ERB unrun, cached by digest so readers share a parse.
+    def self.parse(content)
+      key = Digest::SHA256.hexdigest(content.to_s)
+      PARSED_MUTEX.synchronize { return PARSED[key] if PARSED.key?(key) }
+
+      parsed = read(content)
+      PARSED_MUTEX.synchronize do
+        PARSED.clear if PARSED.size >= MAX_PARSED
+        PARSED[key] = parsed
+      end
+    end
+
+    PARSED = {}
+    PARSED_MUTEX = Mutex.new
+    MAX_PARSED = 512
+    private_constant :PARSED, :PARSED_MUTEX, :MAX_PARSED
+
+    def self.read(content)
+      parsed = YAML.safe_load(ErbSource.with_output_marked(content, ConfigYaml::ERB_OUTPUT), permitted_classes: [ Date, Time, Symbol ], aliases: true)
+      return {} unless parsed
+      return nil unless parsed.is_a?(Hash)
+
+      config = parsed[CONFIG]
+      ignored = config.is_a?(Hash) ? Array(config["ignore"]).map(&:to_s) : []
+      parsed.each_with_object({}) do |(label, attributes), entries|
+        label = label.to_s
+        next if label == CONFIG || label == ANCHOR || ignored.include?(label) || !attributes.is_a?(Hash)
+
+        entries[label] = attributes
+      end.freeze
+    rescue Psych::Exception, ArgumentError
+      nil
     end
+    private_class_method :read
   end
 end