rails-ai-context 5.35.0 → 5.35.2

data/lib/rails_ai_context/introspectors/schema_reader.rb

@@ -54,7 +54,7 @@ module RailsAiContext
         if MigrationReplay.migration_files(migrate_dirs, root: root).any?
           pk_type = SchemaConventions.implicit_pk_type(root)
           return from_tables(MigrationReplay.tables(migrate_dirs, pk_type: pk_type, root: root,
-                                                        adapter: SchemaConventions.database_adapter_for(root, "primary")),
+                                                        adapter: SchemaConventions.database_adapter_for(root, nil)),
                              source: :migrations, path: migrate_dirs.first)
         end
 

data/lib/rails_ai_context/introspectors/source_scan.rb

@@ -168,12 +168,14 @@ module RailsAiContext
         declared = Set.new
         ignored = PathResolver.ignored_dirs(root).map { |dir| PathResolver.root_key(dir) }
         found = PathResolver.extra_model_roots(root).each_with_object([]) do |dir, records|
-          scan_dir(dir, root, real_root, true) do |record|
+          scan_dir(dir, root, real_root, false) do |record|
             next unless seen.add?(record.path)
             next if ignored.any? { |ignored_dir| SafePath.contained?(record.path, ignored_dir) }
 
+            source = SafeFile.read(record.path).to_s
+            record = record.with(path_name: concerns_name(record.path_name, source))
             declared << record.path_name
-            pairs = class_declarations(SafeFile.read(record.path).to_s)
+            pairs = class_declarations(source)
             next if pairs.empty?
 
             records << [ record, pairs ]
@@ -183,6 +185,29 @@ module RailsAiContext
         [ found, declared ]
       end
 
+      # A concerns/ under an app/ root is an autoload root of its own, so its files carry no
+      # `Concerns::`; under a root the app adds it is a namespace, which the file then declares.
+      def concerns_name(path_name, source)
+        return path_name unless path_name.start_with?("Concerns::")
+
+        declared = DeclaredConstant.declared_names(source) + DeclaredConstant.declared_module_names(source)
+        declared.any? { |name| name.split("::").include?("Concerns") } ? path_name : path_name.delete_prefix("Concerns::")
+      end
+
+      # The class a file under a concerns/ is named for; an inner class of a mixin is not it.
+      def concern_class(source, path_name)
+        DeclaredConstant.declaration_named(DeclaredConstant.declarations(source, path_name: path_name), path_name)
+      end
+
+      # Whether a concerns file's own class names a model file's class or a record base as its superclass.
+      def concern_model?(source, path_name, model_names, base_model)
+        declaration = concern_class(source, path_name)
+        return false unless declaration&.superclass
+
+        candidates = declaration.nesting.map { |scope| "#{scope}::#{declaration.superclass}" } << declaration.superclass
+        candidates.any? { |candidate| model_names.include?(candidate.downcase) } || (base_model ? base_model.call(candidates) : false)
+      end
+
       # [name, superclass] of each `class X < Y` that starts its line. A `^` anchor
       # makes Onigmo try every offset, ten times slower over a service tree.
       def class_declarations(source)
@@ -195,7 +220,7 @@ module RailsAiContext
         pairs
       end
 
-      private_class_method :scan, :scan_dir, :ruby_files, :walk_dir, :within?, :extra_model_candidates, :extra_model_declarations, :class_declarations, :lookup, :qualified
+      private_class_method :scan, :scan_dir, :ruby_files, :walk_dir, :within?, :extra_model_candidates, :extra_model_declarations, :class_declarations, :lookup, :qualified, :concern_model?
 
       # `kind: :models` reads model_paths: what model_details lists, not only app/models.
       def each(root, kind:, skip_concerns: true, base_model: nil, &block)
@@ -207,7 +232,17 @@ module RailsAiContext
         end
         return paths(root, kind: kind, skip_concerns: skip_concerns, &read) unless kind == :models
 
-        model_paths(root, base_model: base_model) { |record| read.call(record) unless skip_concerns && record.path_name.start_with?("Concerns::") }
+        model_names = nil
+        model_paths(root, base_model: base_model) do |record|
+          next read.call(record) unless skip_concerns && record.path_name.start_with?("Concerns::")
+
+          # The concerns root does not namespace its files, and one named for a class with a model superclass is a model.
+          source = SafeFile.read(record.path) or next
+          name = concerns_name(record.path_name, source)
+          # An inflection changes only the case of a path's name, so the names compare without it.
+          model_names ||= model_paths(root, base_model: base_model).to_set { |known| known.path_name.delete_prefix("Concerns::").downcase }.merge(MODEL_BASES.map(&:downcase))
+          block.call(record.with(source: source, path_name: name)) if concern_model?(source, name, model_names, base_model)
+        end
       end
 
       # The eager form: reads and parses every file for its declared name.

data/lib/rails_ai_context/migration_status.rb

@@ -33,28 +33,26 @@ module RailsAiContext
     end
 
     # One database's pending migrations, as `db:migrate:status:<name>` reads
-    # them: from that database's own schema_migrations, through a pool of its
-    # own that is removed after, so the app's connections are left as they
-    # are. The primary is asked through the app's own pool. The connection is
-    # made first, so a database that does not exist, or a server that does
-    # not answer, says so rather than reading as nothing pending; a SQLite
-    # file that is not there is said to be missing without connecting, which
-    # would create it.
-    #
-    # @param db_config [ActiveRecord::DatabaseConfigurations::DatabaseConfig]
-    # @return [Hash] { pending: [{ version:, name: }, ...] }, or { error: exception }
-    def self.of_database(db_config, migrate_dir, primary: false)
-      missing = DatabaseFile.missing(db_config)
-      return { error: missing } if missing
-
+    # them: from that database's own schema_migrations, through its pool.
+    def self.pending_on(pool, migrate_dir)
       dirs = Array(migrate_dir).select { |dir| Dir.exist?(dir) }
-      with_pool(db_config, primary: primary) do |pool|
-        pool.with_connection(&:verify!)
-        { pending: dirs.empty? ? [] : pending_in(migration_context(dirs, pool), dirs) }
-      end
-    rescue StandardError => e
-      { error: e }
+      return [] if dirs.empty?
+      # Rails 7.0's schema_migration is a model that finds its pool through the app's handler, where a leased pool is not.
+      return PendingMigrations.for(migrate_dir: dirs, applied: applied_versions(pool.connection)) if schema_migration_model?(pool)
+
+      pending_in(migration_context(dirs, pool), dirs)
+    end
+
+    def self.schema_migration_model?(pool)
+      !pool.respond_to?(:schema_migration) && !pool.connection.respond_to?(:internal_metadata)
+    end
+    private_class_method :schema_migration_model?
+
+    def self.applied_versions(connection)
+      table = ActiveRecord::Base.schema_migrations_table_name
+      connection.table_exists?(table) ? connection.select_values("SELECT version FROM #{connection.quote_table_name(table)}") : []
     end
+    private_class_method :applied_versions
 
     def self.pending_in(context, dirs)
       applied = context.get_all_versions
@@ -65,32 +63,6 @@ module RailsAiContext
       PendingMigrations.for(migrate_dir: dirs, applied: context.get_all_versions)
     end
 
-    # What a pool established for another database belongs to: Rails names a
-    # pool by its owner, and an owner that is no primary class leaves the
-    # app's own pools alone (ActiveRecord::PendingMigrationConnection, which
-    # Rails 7.0 lacks and 7.1 shapes differently).
-    class TemporaryOwner
-      def self.primary_class?
-        false
-      end
-
-      def self.current_preventing_writes
-        false
-      end
-    end
-
-    def self.with_pool(db_config, primary:)
-      return yield(ActiveRecord::Base.connection_pool) if primary
-
-      handler = ActiveRecord::Base.connection_handler
-      begin
-        yield handler.establish_connection(db_config, owner_name: TemporaryOwner)
-      ensure
-        handler.remove_connection_pool(TemporaryOwner.name)
-      end
-    end
-    private_class_method :with_pool
-
     # @return [ActiveRecord::MigrationContext]
     def self.migration_context(migrate_dir, pool = ActiveRecord::Base.connection_pool)
       # Rails 7.2+: MigrationContext takes a schema_migration + internal_metadata

data/lib/rails_ai_context/payload.rb

@@ -118,6 +118,53 @@ module RailsAiContext
       end
     end
 
+    # Where a multi-database entry is configured when that is not the running environment, in words, or nil.
+    def scope_words(database)
+      return nil unless database.is_a?(Hash)
+
+      environments = Array(database[:environments])
+      return "#{environments.first} only" if environments.one?
+      return AppDatabases.environment_phrase(environments) if environments.any?
+
+      "committed dump only" if database[:dump_only]
+    end
+
+    # The same in parentheses, to follow the database's name.
+    def database_mark(database)
+      words = scope_words(database)
+      words ? " (#{words})" : ""
+    end
+
+    # The multi_database section. A payload that holds none (a preset without it) gets the same list
+    # from the app databases, so no mark or name depends on the preset.
+    def multi_database(context)
+      section(context, :multi_database) || Introspectors::MultiDatabaseIntrospector.new(RailsAiContext.default_app).listing
+    end
+
+    def databases(context)
+      Array(multi_database(context)[:databases]).grep(Hash)
+    end
+
+    def named_scope_words(context, name)
+      scope_words(databases(context).find { |database| database[:name].to_s == name.to_s })
+    end
+
+    # What a generated file calls the primary: its own name where another database is the one named primary.
+    def primary_label(context)
+      name = multi_database(context)[:primary_name]
+      name && database_named?(context, "primary") ? name.to_s : "primary"
+    end
+
+    def database_named?(context, name)
+      databases(context).any? { |database| database[:name].to_s == name }
+    end
+
+    # The mark for a database known by its database.yml name.
+    def named_database_mark(context, name)
+      words = named_scope_words(context, name)
+      words ? " (#{words})" : ""
+    end
+
     # Each database past the primary that the schema section read tables
     # for, by its database.yml name.
     def secondary_databases(schema)
@@ -193,7 +240,7 @@ module RailsAiContext
 
       secondary = schema[:secondary_databases].is_a?(Hash) ? schema[:secondary_databases].keys : []
       [ nil, *secondary ].filter_map do |db|
-        live = db.nil? && !parsed_schema?(schema) && schema[:adapter].to_s.match?(/postg/i)
+        live = db.nil? && !parsed_schema?(schema) && DatabaseFamily.of(schema[:adapter].to_s).postgresql?
         shown, data = Introspectors::SchemaIntrospector.qualified_table(name.to_s, database: db&.to_s, live: live)
         # The fourth entry is the name the listing shows the table under, which its models read.
         [ db&.to_s, name.to_s, data, shown ] if data

data/lib/rails_ai_context/pending_migrations.rb

@@ -37,11 +37,10 @@ module RailsAiContext
       migrate_dirs_of(root, Introspectors::SchemaDumpPath.database_name(root, dump_path))
     end
 
-    # The same, for the database database.yml names `name`.
+    # The same, for the app database named `name`.
     def migrate_dirs_of(root, name)
-      entry = RailsAiContext::DatabaseYml.entry(root, name)
-      Introspectors::MigrationReplay.configured_dirs(root, entry) ||
-        [ File.join(root.to_s, "db", name == "primary" || entry ? "migrate" : "#{name}_migrate") ]
+      found = AppDatabases.for(root).of_dump_name(name)
+      found ? found.migrate_dirs : [ File.join(root.to_s, "db", name == "primary" ? "migrate" : "#{name}_migrate") ]
     end
 
     # Every versioned migration file under the directory or directories. One file scan behind

data/lib/rails_ai_context/run_cache.rb

@@ -21,6 +21,11 @@ module RailsAiContext
       end
     end
 
+    # What an open run holds was read before this moment; the run goes on empty.
+    def clear
+      Thread.current[KEY]&.clear
+    end
+
     def active?
       !Thread.current[KEY].nil?
     end

data/lib/rails_ai_context/schema_adapter.rb

@@ -30,15 +30,6 @@ module RailsAiContext
     POSTGRES_ONLY_TYPES = %w[jsonb hstore inet cidr citext tsvector ltree macaddr interval].freeze
     MYSQL_ONLY_TYPES = %w[tinytext mediumtext longtext tinyblob mediumblob longblob].freeze
 
-    # structure.sql dialects as SchemaIntrospector records them, plus adapter names that
-    # mean one of them (activerecord-postgis-adapter registers `postgis`).
-    DIALECTS = {
-      "postgresql" => "PostgreSQL",
-      "postgis" => "PostgreSQL",
-      "mysql" => "MySQL",
-      "sqlite" => "SQLite"
-    }.freeze
-
     DISPLAY_ORDER = %w[PostgreSQL MySQL SQLite].freeze
 
     module_function
@@ -58,9 +49,13 @@ module RailsAiContext
         from_examples(context) || from_gems(context) || "unknown"
     end
 
-    # A connection's adapter_name as the other surfaces name it (PostGIS is PostgreSQL).
+    # A connection's adapter_name as the other surfaces name it (PostGIS is PostgreSQL, Trilogy is MySQL).
     def display(adapter_name)
-      DIALECTS.fetch(adapter_name.to_s.downcase, adapter_name)
+      family = DatabaseFamily.of(adapter_name)
+      return adapter_name unless family.known?
+
+      # A label read back from the payload carries the mark, and the family reads past it.
+      adapter_name.to_s.end_with?(DatabaseFamily::DEFAULT_SUFFIX) ? family.name + DatabaseFamily::DEFAULT_SUFFIX : family.name
     end
 
     def label_with_reason(context)
@@ -91,9 +86,8 @@ module RailsAiContext
       multi = context[:multi_database]
       return nil unless Tools::SectionFetch.usable?(multi)
 
-      primary = Array(multi[:databases]).find { |db| db[:name].to_s == "primary" } ||
-                Array(multi[:databases]).first
-      database_label(primary)
+      # The app databases list puts the primary first.
+      database_label(Array(multi[:databases]).first)
     end
 
     # A secondary database's adapter: its database.yml entry, else the dialect
@@ -114,15 +108,15 @@ module RailsAiContext
       adapter = database[:adapter]
       return nil if placeholder?(adapter)
 
-      name = DIALECTS[adapter.to_s] || GEM_ADAPTERS[adapter.to_s] || adapter
-      database[:adapter_default] ? "#{name} by database.yml default" : name
+      name = display(adapter.to_s)
+      database[:adapter_default] ? name + DatabaseFamily::DEFAULT_SUFFIX : name
     end
 
     def from_examples(context)
       multi = context[:multi_database]
       return nil unless Tools::SectionFetch.usable?(multi)
 
-      candidates(Array(multi[:example_adapters]).map { |name| DIALECTS[name.to_s] || GEM_ADAPTERS[name.to_s] || name.to_s })
+      candidates(Array(multi[:example_adapters]).map { |name| display(name.to_s) })
     end
 
     def from_column_types(schema)
@@ -144,7 +138,8 @@ module RailsAiContext
     def from_dialect(schema)
       return nil unless schema.is_a?(Hash)
 
-      DIALECTS[schema[:dialect].to_s]
+      family = DatabaseFamily.of(schema[:dialect].to_s)
+      family.name if family.known?
     end
 
     # Never a guess: naming one of `pg` and `mysql2` can put a database the app does not