rails-ai-context 5.35.2 → 5.36.0

data/lib/rails_ai_context/database_family.rb

@@ -95,8 +95,8 @@ module RailsAiContext
 
       # @raise [TimedOut, ActiveRecord::StatementInvalid] when PostgreSQL cannot plan the statement
       # @return [Hash, nil] the PostgreSQL JSON plan's top node; nil on other families or when the answer is no plan
-      def plan(connection, sql, timeout:)
-        runtime.plan(connection, sql, timeout)
+      def plan(connection, sql, timeout:, generic: false)
+        runtime.plan(connection, sql, timeout, generic: generic)
       end
 
       # @return [Array<Array(Integer, String, String)>] [result column index, table column, relation] from the
@@ -148,6 +148,17 @@ module RailsAiContext
         runtime.index_tables(connection, schemas)
       end
 
+      # The settings the tool sets for a statement among those it reads (SqlGate.settings_read), each with the session's
+      # own value. Read with no bound: reading a setting waits on no lock.
+      # @return [Hash{String => String}]
+      def own_settings(connection, read)
+        return {} if read.empty?
+
+        runtime.bound_settings(connection).filter_map do |name, query|
+          [ name, connection.select_value(query).to_s ] if read.include?(name)
+        end.to_h
+      end
+
       # @return [Array<Hash>, nil] { name:, bytes: } largest first; nil when the family has none
       def table_sizes(connection)
         runtime.table_sizes(connection)
@@ -268,15 +279,26 @@ module RailsAiContext
     def timed_out?(error)
       # A connection the server dropped is a QueryAborted on Rails 7.1 and later, and it is no timeout.
       return false if defined?(ActiveRecord::ConnectionFailed) && error.is_a?(ActiveRecord::ConnectionFailed)
-      return true if defined?(ActiveRecord::QueryAborted) && error.is_a?(ActiveRecord::QueryAborted)
+      return !canceled?(error.cause) if defined?(ActiveRecord::QueryAborted) && error.is_a?(ActiveRecord::QueryAborted)
       # A wait on a lock that the database's own lock timeout ended.
       return true if error.is_a?(ActiveRecord::LockWaitTimeout)
 
+      TIMEOUT_CODES.include?(native_code(error))
+    end
+
+    # PostgreSQL gives its timeout and a cancel another session sent one error code, and only the server's
+    # message tells them apart. A server that writes its messages in another language reads as the timeout.
+    def canceled?(driver_error)
+      result = driver_error.result if driver_error.respond_to?(:result)
+      result.respond_to?(:error_field) && result.error_field(PG::PG_DIAG_MESSAGE_PRIMARY).to_s.end_with?("due to user request")
+    end
+
+    # @return [Integer, nil] the MySQL or MariaDB error number the driver's error carries
+    def native_code(error)
       cause = error.cause
-      code = if cause.respond_to?(:error_number) then cause.error_number
+      if cause.respond_to?(:error_number) then cause.error_number
       elsif cause.respond_to?(:error_code) then cause.error_code
       end
-      TIMEOUT_CODES.include?(code)
     end
   end
 end

data/lib/rails_ai_context/introspector.rb

@@ -20,6 +20,17 @@ module RailsAiContext
       RunCache.around { introspect_all }
     end
 
+    # Every reader names a database's adapter from this section, so a preset without it, or one where it failed,
+    # still carries the list. A list that cannot be read is a warning, as a failed section is.
+    private def fill_multi_database(context)
+      context[:multi_database] = Introspectors::MultiDatabaseIntrospector.new(app).listing
+    rescue StandardError, ScriptError => e
+      RailsAiContext.log_warn "[rails-ai-context] app databases listing failed: #{e.message}"
+      failed = { error: e.message }.tap { |data| portable_errors!(data) }
+      warnings = (context[:_warnings] ||= [])
+      warnings << { introspector: "multi_database", error: failed[:error] } if warnings.none? { |w| w[:introspector] == "multi_database" }
+    end
+
     private def introspect_all
       context = {
         app_name: app_name,
@@ -60,6 +71,7 @@ module RailsAiContext
       end
       context[:_warnings] = warnings if warnings.any?
 
+      fill_multi_database(context) unless Payload.section(context, :multi_database)
       resolve_schema_adapter(context)
 
       context

data/lib/rails_ai_context/introspectors/eager_load.rb

@@ -121,11 +121,21 @@ module RailsAiContext
         loader = Rails.autoloaders.main
         files.each do |file|
           cpath_for(loader, path, file).constantize
-        rescue StandardError, ScriptError
-          next
+        rescue StandardError, ScriptError => e
+          raised_files[real(file)] = e.message.to_s.lines.first.to_s.strip
         end
       end
 
+      # What loading a file raised this run, by its real path, or nil: Ruby registers a class before its body
+      # runs, so one whose body raised looks loaded with only what ran before the raise.
+      def raised(file)
+        raised_files[file]
+      end
+
+      def raised_files
+        RunCache.fetch([ :eager_load_raised ]) { {} }
+      end
+
       # SourceScan records, each loaded by the constant its file holds. Without
       # the loader's answer (Zeitwerk < 2.6.9) the source's own declaration names
       # it: path_name reads app/services/x.rb as Services::X.

data/lib/rails_ai_context/introspectors/job_introspector.rb

@@ -812,19 +812,30 @@ module RailsAiContext
       # Where a mailer with no actions keeps its interface, such as `self.` methods that
       # fan a notification out to many recipients.
       def no_action_detail(mailer)
+        walked = []
+        outside = mailer.superclass
+        while outside && app_defined?(outside)
+          walked << outside.name
+          outside = outside.superclass
+        end
         { class_actions: callable_class_methods(mailer.singleton_methods(false).map(&:to_s)).sort,
-          parent_class: mailer.superclass&.name }.reject { |_k, v| v.nil? || v == [] }
+          parent_class: inherited_from(walked, outside&.name) }.reject { |_k, v| v.nil? || v == [] }
+      end
+
+      # The parent past the app's own mailers that a mailer with no action of its own takes them from. None past the app
+      # base, whose methods and everything above it are no actions, and none from Rails itself.
+      def inherited_from(walked, outside)
+        return nil if walked.any? { |name| ActionResolver.app_base_name?(name, kind: :mailer) }
+
+        name = outside.to_s.delete_prefix("::")
+        name unless name.empty? || name.start_with?("ActionMailer::", "AbstractController::") ||
+                    ActionResolver.app_base_name?(name, kind: :mailer)
       end
 
       def callable_class_methods(names)
         names.reject { |n| n.start_with?("_") || MAILER_CLASS_CONFIG.include?(n) }
       end
 
-      # A mailer's actions are its public instance methods, and the AST sees
-      # one file at a time. `action_methods` counts the public methods a mailer
-      # inherits too, so a public helper on a base class is an action the
-      # booted tier reports and this one cannot - the entries are tagged STATIC
-      # for that reason.
       # ActionMailer's interceptor and observer hooks. A class or module under
       # app/mailers that implements one is registered with the framework, not
       # delivered by it: reporting OpenProject's Interceptors::DefaultHeaders
@@ -853,7 +864,7 @@ module RailsAiContext
 
       def source_mailers
         @source_mailers ||= begin
-          scanned = source_classes("app/mailers", macros: ACTION_CALLBACKS + MAILER_DECLARATIONS)
+          scanned = source_classes("app/mailers", macros: ACTION_CALLBACKS + MAILER_DECLARATIONS + VISIBILITY_CALLS)
           candidates = scanned.reject { |klass| framework_hook?(klass) } +
                        mailers_outside_mailer_dirs(scanned.map(&:file))
           # A mixin under app/mailers holds a mailer's actions (an Emails::* module); a class
@@ -863,7 +874,8 @@ module RailsAiContext
           bases = abstract_mailer_bases(klasses.reject(&:mixin))
           mailers = klasses.reject { |klass| bases.include?(klass.name) }
 
-          { mailers: mailers.map { |klass| mailer_entry(klass) }.sort_by { |m| m[:name] },
+          by_name = klasses.reject(&:mixin).to_h { |klass| [ klass.name, klass ] }
+          { mailers: mailers.map { |klass| mailer_entry(klass, app_ancestors(klass, by_name, parent_of)) }.sort_by { |m| m[:name] },
             bases: bases.map do |base|
               klass = klasses.find { |k| k.name == base }
               heirs = mailers.reject(&:mixin).map(&:name).select { |name| inherits_from?(name, base, parent_of) }
@@ -1071,6 +1083,9 @@ module RailsAiContext
       # app wrote it, the methods it defines, and who inherits it.
       MAILER_DECLARATIONS = %i[layout helper helper_method include default default_url_options=].freeze
 
+      # `private :name` in a mailer hides a method it inherits, and `public :name` shows one.
+      VISIBILITY_CALLS = %i[private protected public].freeze
+
       def mailer_base_record(name, file, source, macros, methods, heirs)
         declares = SourceIntrospector.outside_defs(macros, methods).select { |m| (MAILER_DECLARATIONS + ACTION_CALLBACKS).include?(m[:macro]) }
           .sort_by { |m| m[:offset] }.map { |m| written(source, m) }
@@ -1100,6 +1115,20 @@ module RailsAiContext
         @candidate_bodies[name] ||= SourceIntrospector.outside_defs(job_candidates[name].ast[:macros], job_candidates[name].ast[:methods])
       end
 
+      # The app's own classes a class inherits from, nearest first.
+      def app_ancestors(klass, by_name, parent_of)
+        chain = []
+        name = klass.name
+        while chain.size < SuperclassChain::MAX_DEPTH
+          superclass, nesting = parent_of[name]
+          name = SuperclassChain.resolve_in_scope(name, superclass, nesting: nesting) { |candidate| candidate if by_name.key?(candidate) }
+          break if name.nil? || name == klass.name || chain.any? { |ancestor| ancestor.name == name }
+
+          chain << by_name[name]
+        end
+        chain
+      end
+
       def inherits_from?(name, base, parent_of, seen = [])
         return false if seen.include?(name) || seen.size >= SuperclassChain::MAX_DEPTH
 
@@ -1158,12 +1187,22 @@ module RailsAiContext
         false
       end
 
-      # What the static tier can say a mailer offers. A class with no action of its own is
-      # still a mailer: its actions come from a parent or mixin, or it offers class methods.
-      def mailer_entry(klass)
+      # The public methods of a mailer and of its app parents below the app base, each with the visibility the nearest
+      # gives it; tagged STATIC, since a gem's base or a mixin can add actions only the booted tier sees.
+      def mailer_entry(klass, ancestors)
+        # The app base's public methods are no actions, as the booted tier subtracts them; its callbacks still filter.
+        action_chain = [ klass, *ancestors.take_while { |declaring| !ActionResolver.app_base_name?(declaring.name, kind: :mailer) } ]
+        visibility = {}
+        action_chain.each do |declaring|
+          own = ActionResolver.own_methods(declaring.methods, declaring.name).select { |m| m[:scope] == :instance }
+          own.each { |m| visibility[m[:name]] ||= m[:visibility] }
+          declaring.macros.each do |m|
+            m[:args].each { |name| visibility[name.to_s] ||= m[:macro] } if VISIBILITY_CALLS.include?(m[:macro])
+          end
+        end
         actions = ActionResolver.deliverable_actions(
-          ActionResolver.own_actions(klass.methods, class_name: klass.name),
-          klass.macros.select { |m| ACTION_CALLBACKS.include?(m[:macro]) }.flat_map { |m| m[:args] }
+          visibility.select { |name, seen| seen == :public && !name.start_with?("_") }.keys.sort,
+          [ klass, *ancestors ].flat_map { |declaring| declaring.macros.select { |m| ACTION_CALLBACKS.include?(m[:macro]) }.flat_map { |m| m[:args] } }
         )
 
         entry = { name: klass.name, file: klass.file, actions: actions,
@@ -1174,7 +1213,8 @@ module RailsAiContext
           .select { |m| m[:scope] == :class && m[:visibility] == :public }
           .map { |m| m[:name] }
         entry[:class_actions] = class_actions.sort if (class_actions = callable_class_methods(class_actions)).any?
-        entry[:parent_class] = klass.parent_class if klass.parent_class
+        source = inherited_from(ancestors.map(&:name), (ancestors.last || klass).parent_class)
+        entry[:parent_class] = source if source
         entry
       end
 

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -601,6 +601,12 @@ module RailsAiContext
             source = model_source(record.path).to_s
             path_name = SourceScan.concerns_name(path_name, source)
           end
+          # A class whose body raised is registered holding what ran before the raise.
+          if EagerLoad.raised(record.path)
+            half_built = DeclaredConstant.named(model_source(record.path).to_s, path_name)
+            models.reject! { |model| model.name == half_built }
+            known.delete(half_built)
+          end
           next if known.include?(path_name)
           next if config.excluded_models.include?(path_name)
           next if path_name != record.path_name && mixin_path?(record.path_name.underscore, source)
@@ -1128,21 +1134,17 @@ module RailsAiContext
 
       def extract_sti_info(model)
         type_column = model.inheritance_column.to_s
-        has_type_column = if model.connected? && model.table_exists?
-          model.columns_hash.key?(type_column)
-        else
-          SchemaReader.for(app.root).column?(model.table_name, type_column)
-        end
-
-        return nil unless has_type_column
+        connected = model.connected? && model.table_exists?
+        return nil if type_column.empty?
+        return nil if connected ? !model.columns_hash.key?(type_column) : lacks_column?(model.table_name, type_column)
 
         children = DeclaredConstant.carried(model.descendants).map(&:name).sort
 
         parent = model.superclass
-        sti_parent = if parent && parent != ActiveRecord::Base &&
-                        (!defined?(ApplicationRecord) || parent != ApplicationRecord)
-          parent.name
-        end
+        # An abstract base (ApplicationRecord, or the one a second database connects through) holds no rows of its own.
+        sti_parent = parent.name if parent && parent != ActiveRecord::Base && !parent.abstract_class?
+        # A table db/schema.rb does not hold is in another database, so only a class family says it is STI.
+        return nil if !connected && !SchemaReader.for(app.root).table?(model.table_name) && sti_parent.nil? && children.empty?
 
         {
           sti_base: sti_parent.nil? && children.any?,

data/lib/rails_ai_context/introspectors/schema_introspector.rb

@@ -544,7 +544,18 @@ module RailsAiContext
 
       def declaration_keys
         declared = declared_table_names
-        { declared_tables: declared, declared_in: (relative_dump_path(schema_file_path) if declared) }
+        keys = { declared_tables: declared, declared_in: (relative_dump_path(schema_file_path) if declared) }
+        shared = declared && shared_dump
+        shared ? keys.merge(shared_dump: shared) : keys
+      end
+
+      # Rails dumps both the first database and the one named primary to schema.rb, so the
+      # file holds whichever was dumped last.
+      def shared_dump
+        dump = File.expand_path(schema_file_path)
+        primary = app_databases.primary
+        other = app_databases.find { |db| db.here && db != primary && db.dump && File.expand_path(db.dump.path) == dump }
+        { primary: primary.name, other: other.name } if primary && other
       end
 
       # The configured dump first (database.yml's schema_dump, schema_format), then the default files.

data/lib/rails_ai_context/payload.rb

@@ -135,10 +135,9 @@ module RailsAiContext
       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.
+    # The multi_database section, which the introspector seam fills on every preset.
     def multi_database(context)
-      section(context, :multi_database) || Introspectors::MultiDatabaseIntrospector.new(RailsAiContext.default_app).listing
+      section(context, :multi_database) || {}
     end
 
     def databases(context)

data/lib/rails_ai_context/secret_columns.rb

@@ -56,20 +56,21 @@ module RailsAiContext
         raise unreadable(connection) unless relations
 
         relations = relations.merge(CATALOG_CREDENTIALS) if family.plan_checks?
-        new(relations: relations, encrypted: encrypted_from(context), connection: connection, **definitions_from(connection, schemas))
+        new(relations: relations, encrypted: encrypted_from(context), connection: connection, family: family,
+            **definitions_from(connection, schemas))
       end
       statement.to_s.strip.empty? ? secrets : secrets.cover(statement)
     end
 
-    # A name or a statement as the databases compare names: case folded, a dotted capital I read as i (MySQL does,
-    # Ruby's downcase keeps the dot), and runs of spaces squeezed, so a name is found in text squeezed or not.
-    def self.fold(text)
-      text.to_s.downcase.delete("\u0307").squeeze(" ")
+    # A name or a statement as the databases compare names: case folded (ASCII alone with `ascii:`, as SQLite folds),
+    # a dotted capital I read as i as MySQL reads it, and runs of spaces squeezed, so text squeezed or not matches.
+    def self.fold(text, ascii: false)
+      ascii ? text.to_s.downcase(:ascii).squeeze(" ") : text.to_s.downcase.delete("\u0307").squeeze(" ")
     end
 
     # Matches the name as a whole identifier in folded text, whatever characters it holds and however it is quoted.
-    def self.identifier(name)
-      name = fold(name)
+    def self.identifier(name, ascii: false)
+      name = fold(name, ascii: ascii)
       spellings = [ name, name.gsub('"', '""'), name.gsub("`", "``"), name.gsub("'", "''") ].uniq.map { |spelling| Regexp.escape(spelling) }
       /(?<!\p{Word})(?:#{spellings.join("|")})(?!\p{Word})/
     end
@@ -158,9 +159,11 @@ module RailsAiContext
     # Each argument is what the DatabaseFamily::Family read of the same name answers. views is nil when the
     # database's views are not known. connection: where more schemas are read from; with none the rule keeps what it was given.
     def initialize(relations: {}, encrypted: [], views: nil, traced_views: [], generated: {}, index_tables: {}, connection: nil,
-                   config: RailsAiContext.configuration)
-      fold = self.class.method(:fold)
-      @redacted = (Array(config.query_redacted_columns) + BUILT_IN_NAMES).to_set(&fold)
+                   family: nil, config: RailsAiContext.configuration)
+      @ascii = family&.sqlite? || false
+      fold = method(:fold)
+      @configured = Array(config.query_redacted_columns)
+      @redacted = (@configured + BUILT_IN_NAMES).to_set(&fold)
       @allowed = Array(config.query_allowed_columns).to_set(&fold)
       @encrypted = Array(encrypted).to_set(&fold)
       @connection = connection
@@ -222,22 +225,25 @@ module RailsAiContext
 
     # Whether the relation's columns were read. A PostgreSQL relation is asked for as `schema.relation`.
     def knows?(relation)
-      @columns.key?(self.class.fold(relation))
+      @columns.key?(fold(relation))
     end
 
     def secret?(name)
-      down = self.class.fold(name)
+      down = fold(name)
       return false if down.empty?
       return true if encrypted?(down)
       return false if @allowed.include?(down)
 
-      @generated.key?(down) || @redacted.include?(down) || heuristic?(down) || RailsAiContext::Redaction.secret_name?(down)
+      # What a name means is read with every letter folded, whatever the database folds.
+      meaning = self.class.fold(name)
+      @generated.key?(down) || @redacted.include?(down) || @secret_meanings.include?(meaning) || heuristic?(meaning) ||
+        RailsAiContext::Redaction.secret_name?(meaning)
     end
 
     # True for an `encrypts` column and for a generated column that reads one: neither is released by name.
     # Generated columns of one name on two tables are one name here, encrypted when either reads such a column.
     def encrypted?(name, through = [])
-      down = self.class.fold(name)
+      down = fold(name)
       return true if @encrypted.include?(down)
 
       !through.include?(down) && @generated.fetch(down, []).any? { |source| encrypted?(source, through + [ down ]) }
@@ -245,14 +251,14 @@ module RailsAiContext
 
     # @return [String, nil] a secret column a generated column's expression reads, an `encrypts` one first
     def generated_from(name)
-      sources = @generated.fetch(self.class.fold(name), [])
+      sources = @generated.fetch(fold(name), [])
       sources.find { |source| encrypted?(source) } || sources.first
     end
 
     # [view, why] for the first refused view the text names, or nil. A view's definition renames a
     # column outside the statement, where no check on the statement reads it.
     def refused_view_in(text)
-      down = self.class.fold(text)
+      down = fold(text)
       view, why = @refused_views.find { |name, _why| names?(down, name) }
       [ spelled(view), why ] if view
     end
@@ -260,7 +266,7 @@ module RailsAiContext
     # Why the view at exactly this place is refused, or nil. The plan names a relation as `schema.relation`, so a table
     # is not taken for a view of its name in another schema; a view with no definition read is told by its bare name.
     def placed_view_refusal(relation, name)
-      placed, bare = self.class.fold(relation), self.class.fold(name)
+      placed, bare = fold(relation), fold(name)
       return @refused_views[placed] if @views&.key?(placed)
 
       @refused_views[bare] if @views&.key?(bare) && @views[bare].nil?
@@ -268,21 +274,21 @@ module RailsAiContext
 
     # Whether the relation is a view whose rows the plan does not trace to their table columns.
     def stored_view?(relation)
-      placed = self.class.fold(relation)
+      placed = fold(relation)
       !@views.nil? && @views.key?(placed) && !@traced.include?(placed)
     end
 
     # [table, why] for the first table the text names that is never read, or nil: the file's pages, a shadow
     # table, and a virtual table or its vocabulary when the virtual table holds a secret column.
     def unread_table_in(text)
-      down = self.class.fold(text)
+      down = fold(text)
       table, why = @unread_tables.find { |name, _why| names?(down, name) }
       [ spelled(table), why ] if table
     end
 
     # The first relation holding a secret column that the statement's text names, or nil.
     def relation_named_in(text)
-      down = self.class.fold(text)
+      down = fold(text)
       relation = @by_relation.each_key.find { |name| names?(down, name) }
       relation && spelled(relation)
     end
@@ -290,20 +296,25 @@ module RailsAiContext
     # The first secret name the statement's text names, or nil. Case-insensitive
     # and word-bounded, so a table or alias that merely holds a secret word passes.
     def named_in(text)
-      down = self.class.fold(text)
+      down = fold(text)
       @named.each { |name, pattern| return name if down.match?(pattern) }
       nil
     end
 
+    # view => its definition, for each view the text names and each one their definitions name.
+    def view_definitions_in(text)
+      views_reached(text).keys.filter_map { |view| [ spelled(view), @views[view] ] if @views[view] }.to_h
+    end
+
     # The schema's real secret columns, read by the PostgreSQL plan checks.
     attr_reader :in_schema
 
     def of_relation(relation)
-      @by_relation.fetch(self.class.fold(relation), [])
+      @by_relation.fetch(fold(relation), [])
     end
 
     def relation_secret?(relation)
-      @by_relation.key?(self.class.fold(relation))
+      @by_relation.key?(fold(relation))
     end
 
     private
@@ -325,11 +336,11 @@ module RailsAiContext
     # view => the view the text names that leads to it, for each view the text names and each one their
     # definitions name. A view the plan reads through is no start: its relations are in the plan.
     def views_reached(text)
-      down = self.class.fold(text)
+      down = fold(text)
       reached = @views.to_h.keys.select { |view| !@traced.include?(view) && names?(down, view) }.to_h { |view| [ view, view ] }
       waiting = reached.keys
       while (view = waiting.shift)
-        definition = self.class.fold(@views[view])
+        definition = fold(@views[view])
         (@views.keys - reached.keys).each do |other|
           next unless names?(definition, other)
 
@@ -341,8 +352,8 @@ module RailsAiContext
     end
 
     def too_deep(found, followed, family)
-      found = found.map { |schema| self.class.fold(schema) }
-      view = followed.find { |name, _start| (dotted_names(self.class.fold(@views[name])) & found).any? }&.last
+      found = found.map { |schema| fold(schema) }
+      view = followed.find { |name, _start| (dotted_names(fold(@views[name])) & found).any? }&.last
       Unreadable.new("The view `#{spelled(view)}` leads through more #{family.postgresql? ? "schemas" : "databases"} than rails_query follows, " \
         "so the secret columns it could read cannot be told and no statement that names it runs.")
     end
@@ -353,7 +364,7 @@ module RailsAiContext
     end
 
     def learn(relations:, views: nil, traced_views: [], generated: {}, index_tables: {})
-      fold = self.class.method(:fold)
+      fold = method(:fold)
       [ relations, views, index_tables ].each { |named| named&.each_key { |name| @spelled[fold.call(name)] ||= name.to_s } }
       relations.each { |relation, names| @columns[fold.call(relation)].concat(Array(names).map(&fold)) }
       generated.each do |relation, expressions|
@@ -383,12 +394,15 @@ module RailsAiContext
     end
 
     def flag_secret_columns(columns)
+      # A configured name that no column spells as the database folds it still holds the columns it folds to.
+      known = columns.values.flatten.to_set
+      @secret_meanings = (BUILT_IN_NAMES + @configured.reject { |name| known.include?(fold(name)) }).to_set { |name| self.class.fold(name) }
       @by_relation = columns.each_with_object({}) do |(relation, names), acc|
         flagged = names.uniq.select { |c| secret?(c) }
         acc[relation] = flagged unless flagged.empty?
       end
       @in_schema = @by_relation.values.flatten.uniq.freeze
-      @named = ((@redacted.to_a - @allowed.to_a) | @encrypted.to_a | @in_schema).map { |c| [ c, self.class.identifier(c) ] }
+      @named = ((@redacted.to_a - @allowed.to_a) | @encrypted.to_a | @in_schema).map { |c| [ c, identifier(c) ] }
     end
 
     # Whether another secret column was found that a generated column reads. Every source of a name is kept.
@@ -396,8 +410,8 @@ module RailsAiContext
       found = false
       generated.each_value do |expressions|
         expressions.each do |column, expression|
-          column = self.class.fold(column)
-          down = self.class.fold(expression)
+          column = fold(column)
+          down = fold(expression)
           sources = @named.filter_map { |name, pattern| name if name != column && down.match?(pattern) } - @generated.fetch(column, [])
           next if sources.empty?
 
@@ -410,7 +424,7 @@ module RailsAiContext
 
     # view name => why it is refused, followed through views built on refused views.
     def refused_views(views)
-      views = views.to_h { |view, definition| [ self.class.fold(view), self.class.fold(definition) ] }
+      views = views.to_h { |view, definition| [ fold(view), fold(definition) ] }
       refused = views.transform_values { |definition| refusal_of(definition) }.compact
       loop do
         nested = views.filter_map do |view, definition|
@@ -439,7 +453,7 @@ module RailsAiContext
               "table reads a column by its position, with no name written"
           end
         end
-        unread[self.class.fold(table)] = why if why
+        unread[fold(table)] = why if why
       end
     end
 
@@ -453,10 +467,10 @@ module RailsAiContext
     # its rows, or its words, are theirs.
     def built_on_unread(index_tables)
       index_tables.each_with_object({}) do |(table, (kind, owner, definition)), built|
-        table = self.class.fold(table)
+        table = fold(table)
         next if definition.nil? || @unread_tables.key?(table)
 
-        down = self.class.fold("#{owner if kind == :vocabulary} #{relation_words(table, definition)}")
+        down = fold("#{owner if kind == :vocabulary} #{relation_words(table, definition)}")
         view, why = @refused_views.find { |name, _why| name != table && names?(down, name) }
         other = @unread_tables.keys.find { |name| name != table && names?(down, name) } unless view
         built[table] = "its definition names the view `#{spelled(view)}`, which is not queried: #{why}" if view
@@ -476,7 +490,7 @@ module RailsAiContext
       mod_name = mod.delete(%q("'`[]))
       columns = mod_name.match?(/\Afts[345]\z/i) ? @columns[table] : []
       named = arguments.to_s.scan(MODULE_ARGUMENT).reject do |argument|
-        !argument.include?("=") && columns.include?(self.class.fold(argument[LEADING_NAME].to_s.delete(%q("'`[])).strip))
+        !argument.include?("=") && columns.include?(fold(argument[LEADING_NAME].to_s.delete(%q("'`[])).strip))
       end
       # A vocabulary's last argument is its type (row, col or instance), which SQLite reads as no relation.
       named.pop if mod_name.casecmp?("fts5vocab") && named.size > 1
@@ -496,7 +510,15 @@ module RailsAiContext
     end
 
     def names?(down, name)
-      down.match?(self.class.identifier(name))
+      down.match?(identifier(name))
+    end
+
+    def fold(text)
+      self.class.fold(text, ascii: @ascii)
+    end
+
+    def identifier(name)
+      self.class.identifier(name, ascii: @ascii)
     end
 
     def heuristic?(down)