activerecord-minimizer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ce54c61288bef93e5fb13a4f7b040549145511a46fa548b110565f7d9df146b6
+  data.tar.gz: c9884dbd4f7c17218a23af522b93a9eef4d1f4144fff706cb09a76aa6ec4f7d5
+SHA512:
+  metadata.gz: e6745aa3893a7742b4002879166b7d2f547789a1382aa982bded4ee5398ea7955601bdee59e17695281c1f20006a129b9733ac054787ad68446550f7c37e6e1f
+  data.tar.gz: 1d2db1e229d5b09b45e41751dbbac7869a3581878db7286adaea75245ef565d9da6f17b2519e600a75b5daf64cb2275e89fdf7515029e089feecaca5d89fed54

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.1.0 (2026-10-18)
+
+First release.
+
+- Slim: only readers and writers are generated; strict mode (the default) removes the other attribute methods and names the replacement in the NoMethodError. `strict = false` generates them on first call instead.
+- Keep list (`config/ar_minimizer_keep.txt`) and profiling (`AR_MINIMIZER_PROFILE`, `ar_minimizer:profile`) for methods gems call by name.
+- Manifest (`ar_minimizer:manifest`, `ar_minimizer:manifest:check`).
+- Call-site compilation at load time, in templates, or in place (`ar_minimizer:build`), for receivers whose model is known; `guards = true` also compiles the rest behind a class check.
+- Enum predicates and bang methods as plain methods.
+- Small records: no Hashes for records that never fill them.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sampo Kuokkanen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,143 @@
+# activerecord-minimizer
+
+Active Record generates a reader, a writer and one method per attribute
+method pattern for every column of every model: `name?`, `name_changed?`,
+`name_was`, `saved_change_to_name?`, `name_before_type_cast`,
+`restore_name!`, ... 21 patterns in Rails 8.1, so 21 methods per column.
+activerecord-minimizer generates the readers and writers only, and compiles
+the call sites that used the rest into the calls they stood for. Part of
+[rails-minify](../rails-minify).
+
+```ruby
+# Gemfile
+gem "activerecord-minimizer"
+
+# config/environments/production.rb
+config.ar_minimizer.slim = true
+```
+
+## Strict mode
+
+With `slim` on, the other 19 methods per column are gone. Calling one raises
+`NoMethodError` naming its replacement, and `respond_to?` says no:
+
+```
+name_changed? was removed by activerecord-minimizer's strict mode; use attribute_changed?(:name, ...)
+```
+
+[rubocop-minify](../rubocop-minify) rewrites those calls in your Ruby and ERB.
+Gems that call them by name (Devise's `will_save_change_to_email?`, Active
+Storage's `service_name_changed?`, counter caches) get them back from a keep
+list, `config/ar_minimizer_keep.txt`, one `name` or `Model#name` per line.
+To find what to put there, run the test suite with `strict = false` and
+`AR_MINIMIZER_PROFILE=tmp/ar_minimizer`, then `bin/rails ar_minimizer:profile`.
+
+Rails itself still gets what it needs:
+
+* `<attr>_before_type_cast` and `<attr>_came_from_user?` answer `respond_to?`
+  and are generated on first call. Form fields and numericality validation ask
+  before calling them, and quietly do something else when told no (a form
+  would show the cast value, `"abc"` would validate as 0).
+* `<enum>_for_database` and `updated_at_before_type_cast`/`_came_from_user?`
+  are generated up front: Rails calls them on hot paths.
+* Aliases (`alias_attribute`, Rails' own `id_value`), partial selects
+  (`select(:id)`) and columns only one query selects (`AS trips_count`) work
+  as before.
+
+`config.ar_minimizer.strict = false` keeps the removed methods working: the
+first call to one generates it on that model.
+
+## Compiling call sites
+
+Calls whose receiver is known to be a record of a model with that column are
+compiled to what the generated method would have done:
+
+```ruby
+# what you write                       # what runs
+user.name_changed?                     user.attribute_changed?(-"name")
+user.active?                           (!!user.active)
+user.age?                              ((user.age || 0) != 0)
+user.name?                             (!user.name.blank?)
+```
+
+`name?` compiles by column type, to what `query_attribute` works out to for
+those values; enums, time zone aware datetimes, `encrypts`, `serialize` and
+`normalizes` columns keep `query_attribute(:name)`. The receiver's type comes
+from the code (Prism) and the manifest: `self` inside a model or a concern it
+includes, locals and instance variables assigned from `Model.find`, `.new`,
+`.create`, finders and scopes, associations, and block parameters of
+relations. A receiver that may be nil gets a nil check instead
+(`nil == user ? user.name? : ...`). Calls whose receiver isn't known are left
+as written; `config.ar_minimizer.guards = true` compiles them too, behind a
+class check.
+
+Where it compiles:
+
+* **Load time** (`config.ar_minimizer.load_time = true`) compiles `app/` and
+  `lib/` as Ruby loads them, through require-hooks, so bootsnap caches the
+  compiled iseqs. Source files stay untouched and no database is needed.
+* **Views** (`config.ar_minimizer.views = true`) compiles each template's Ruby
+  as Action View compiles it (any handler: ERB, Herb, ...).
+* **Build** (`RAILS_ENV=production bin/rails ar_minimizer:build`) rewrites
+  `app/` and `lib/` in place instead, like explode_sqlite. Production only (or
+  `FORCE=1`); `DRY_RUN=1` previews.
+
+All three read the **manifest**, `config/ar_minimizer.json`, written by
+`bin/rails ar_minimizer:manifest`: per model its columns and their query kind,
+the attribute method patterns, hand-written methods, superclass, app modules,
+associations, scopes, and names it defines another way (an enum predicate
+with the same name as another model's column). Commit it like
+`db/schema.rb`; `bin/rails ar_minimizer:manifest:check` fails CI when it's
+stale, and an eager-loading boot logs an error if it is.
+
+Never compiled: methods any model defines by hand, names used as columns,
+primary key methods, `defined?(...)`, calls with blocks, heredoc arguments.
+
+## More
+
+* **Enums** (`config.ar_minimizer.enums = true`) replaces the closures Rails
+  defines for enum predicates and bang methods, which build and intern the
+  `<name>_for_database` symbol on every call, with ordinary methods carrying
+  the enum's values: `def published? = public_send(:status_for_database) == 1`.
+  1.3–1.6× faster predicates; non-finite float values keep Rails' closures.
+* **Small records** (`config.ar_minimizer.small_records = true`). A loaded
+  record owns two Hashes most records never put anything in, 160 bytes each:
+  the association cache and the attribute set's Attribute objects. Both start
+  as one shared frozen empty Hash and get their own on the first insert. A
+  read-only record goes from 1,480 to 1,160 bytes (23 columns), at the same
+  speed. Destroyed and frozen records still raise on writes.
+* **Census** (`ArMinimizer::Census`, run by rails-minify's
+  `bin/rails minify:census`): how many call sites compile, and why the others
+  don't.
+
+## Numbers
+
+Rails 8.1, Ruby 4.0, M-series Mac. `bench/calls.rb`, ns per call:
+
+| call                   | stock | compiled | stock (YJIT) | compiled (YJIT) |
+|------------------------|------:|---------:|-------------:|----------------:|
+| `name?` (string)       |  1050 |      548 |          565 |             328 |
+| `age?` (integer)       |   843 |      380 |          464 |             212 |
+| `active?` (boolean)    |   535 |      380 |          283 |             214 |
+| `name_changed?`        |   768 |      718 |          405 |             327 |
+
+(Measured with the class guard; calls on known receivers skip it.)
+
+On golf-buddy (191 models, 2009 columns):
+
+* Generated attribute methods at boot: 44,835 → about 4,500. Memory used by
+  `define_attribute_methods`: 16.4 → about 6 MB; time 374 → about 225 ms.
+* Test suite (4317 runs) in strict mode, after rubocop-minify's rewrites and
+  with a 41-line keep list: the same results as the untouched app.
+
+## Requirements and caveats
+
+* Ruby 3.4+, Rails 8.0, 8.1 and main (`rake test:rails`).
+* It overrides `define_attribute_method_pattern` and the instance
+  `attribute_method?`, both private, and calls nodoc `_has_attribute?`.
+* A stale manifest can compile a call to a method added by hand since: keep
+  `ar_minimizer:manifest:check` in CI.
+* Methods generated lazily (`strict = false`) after a server forks are per
+  worker; list hot ones in the keep file to generate them at boot.
+* Error highlighting in compiled views can point at the wrong column. Line
+  numbers are right.

data/lib/activerecord-minimizer.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "ar_minimizer"

data/lib/ar_minimizer/build.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ArMinimizer
+  # Rewrites application files in place. Run once per release on the
+  # production host (or image build), after the app has booted with every model
+  # loaded and the schema in place. Never commit the output.
+  class Build
+    NotProduction = Class.new(StandardError)
+    Report = Data.define(:files_changed, :sites, :skipped)
+
+    def initialize(root:, index: Index.from_models, paths: %w[app lib], env: ENV["RAILS_ENV"] || ENV["RACK_ENV"],
+      dry_run: false, force: false, out: nil, guards: false)
+      @root = root.to_s
+      @index = index
+      @paths = paths
+      @env = env
+      @dry_run = dry_run
+      @force = force
+      @out = out
+      @guards = guards
+    end
+
+    def run
+      unless @force || @env == "production"
+        raise NotProduction, "ar_minimizer rewrites source in place; run it with RAILS_ENV=production, " \
+          "or override with FORCE=1 (rake) or force: true (Ruby)"
+      end
+
+      files_changed = sites = 0
+      skipped = []
+      files.each do |file|
+        relative = file.delete_prefix("#{@root}/")
+        result = Rewriter.new(index: @index, path: relative, guards: @guards).rewrite(File.read(file))
+        skipped.concat(result.skipped)
+        result.skipped.each { @out&.puts "ar_minimizer: skipped #{it}" }
+        next if result.sites.zero?
+
+        files_changed += 1
+        sites += result.sites
+        @out&.puts "ar_minimizer: #{relative} (#{result.sites} calls)"
+        File.write(file, result.source) unless @dry_run
+      end
+      @out&.puts "ar_minimizer: #{sites} calls in #{files_changed} files, " \
+        "#{@index.size} compilable method names#{" (dry run)" if @dry_run}"
+      Report.new(files_changed, sites, skipped)
+    end
+
+    private
+
+    def files
+      @paths.flat_map { Dir.glob(File.join(@root, it, "**", "*.rb")) }.sort
+    end
+  end
+end

data/lib/ar_minimizer/census.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ArMinimizer
+  # What the attribute-method and enum compilers cover in an app.
+  module Census
+    Result = Data.define(:models, :columns, :stock_methods, :generated_methods, :enum_methods, :enum_compiled,
+      :sites, :files, :manifest) do
+      def lines(verbose: false)
+        [
+          "models: #{models}, #{columns} columns",
+          "attribute methods: #{stock_methods} in stock Rails, #{generated_methods || "n/a (slim off)"} generated with slim",
+          "enum methods: #{enum_compiled}/#{enum_methods} compiled",
+          "attribute call sites: #{sites} compilable in #{files} files under app/ and lib/",
+          "manifest: #{manifest}",
+        ]
+      end
+    end
+
+    def self.report(root:, models: ActiveRecord::Base.descendants, guards: false)
+      models = models.reject { it.abstract_class? || !Index.table?(it) }
+      index = Index.new(models.map { Index.describe(it) }, keep: Slim.keep || Slim::DEFAULT_KEEP)
+      stock = models.sum { it.attribute_method_patterns.count * (it.attribute_names.size + it.attribute_aliases.size) }
+      generated = if Slim.enabled?
+        models.each(&:define_attribute_methods)
+        models.sum { it.send(:generated_attribute_methods).instance_methods(false).size }
+      end
+      enum_methods = enum_compiled = 0
+      models.each do |model|
+        mod = model.instance_variable_get(:@_enum_methods_module) or next
+        mod.instance_methods(false).each do |name|
+          enum_methods += 1
+          enum_compiled += 1 if mod.instance_method(name).source_location&.first.to_s.start_with?("enum ")
+        end
+      end
+      sites = files = 0
+      Dir.glob(File.join(root.to_s, "{app,lib}", "**", "*.rb")).each do |file|
+        n = Rewriter.new(index: index, path: file, guards: guards).rewrite(File.read(file)).sites
+        sites += n
+        files += 1 if n.positive?
+      end
+      Result.new(models.size, models.sum { it.attribute_names.size }, stock, generated, enum_methods, enum_compiled,
+        sites, files, manifest_state(root, index))
+    end
+
+    def self.manifest_state(root, index)
+      path = File.join(root.to_s, "config/ar_minimizer.json")
+      return "none (config/ar_minimizer.json; needed for load-time compilation)" unless File.exist?(path)
+
+      File.read(path) == Manifest.dump(index) ? "up to date" : "out of date: run bin/rails ar_minimizer:manifest"
+    end
+  end
+end

data/lib/ar_minimizer/enums.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ArMinimizer
+  # Enum predicates and bang methods as ordinary methods.
+  #
+  # Rails defines them with closures, and each predicate call builds and
+  # interns the `<name>_for_database` symbol before calling it:
+  #
+  #   # def active?() status_for_database == 0 end      (Rails' own comment)
+  #   define_method("#{value_method_name}?") { public_send(:"#{name}_for_database") == value }
+  #
+  # Here the enum's literal data goes into the method source instead, as
+  # Roundhouse does for macros with literal arguments:
+  #
+  #   def active? = public_send(:status_for_database) == 0
+  #   def active! = update!("status" => 0)
+  #
+  # Rails still runs first (conflict detection, scopes); only the two methods
+  # are replaced. Rails allows booleans, integers, floats, symbols and strings
+  # as values; non-finite floats, and method names that aren't plain
+  # identifiers, keep Rails' closures.
+  module Enums
+    IDENTIFIER = /\A[a-zA-Z_][a-zA-Z0-9_]*\z/
+
+    class << self
+      # Before models load (their class bodies declare the enums).
+      def install!
+        @enabled = true
+        mod = ActiveRecord::Enum.const_get(:EnumMethods)
+        mod.prepend(Definer) unless mod < Definer
+      end
+
+      def disable! = @enabled = false
+
+      def enabled? = @enabled == true
+
+      def literal(value)
+        case value
+        when Integer, String, Symbol, true, false, nil then value.inspect
+        when Float then value.inspect if value.finite?
+        end
+      end
+    end
+
+    module Definer
+      private
+
+      def define_enum_methods(name, value_method_name, value, scopes, instance_methods)
+        super
+        return unless instance_methods && Enums.enabled?
+        return unless value_method_name.match?(IDENTIFIER) && (literal = Enums.literal(value))
+
+        remove_method(:"#{value_method_name}?", :"#{value_method_name}!")
+        module_eval(<<~RUBY, "enum #{klass.name}.#{name}", 1)
+          def #{value_method_name}? = public_send(#{:"#{name}_for_database".inspect}) == #{literal}
+          def #{value_method_name}! = update!(#{name.inspect} => #{literal})
+        RUBY
+      end
+    end
+  end
+end

data/lib/ar_minimizer/index.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module ArMinimizer
+  # Which method names the rewriter may compile, built from the loaded models.
+  # A name qualifies when, in every model that has it, it is a generated
+  # attribute method for the same attribute and proxy, e.g. "name_changed?" ->
+  # attribute_changed?("name"). It is dropped if any model defines it by hand
+  # (the hand-written method must keep running) or uses it as a column.
+  class Index
+    # classes: names of the models that have the attribute, for the call-site guard.
+    # query: for name?, what the column's values let it compile to (see QUERY).
+    Entry = Data.define(:proxy, :attr, :args, :classes, :query) do
+      # The proxy as callable on an explicit receiver: public ones directly,
+      # private ones (attribute_will_change!, ...) are nil and go through __send__.
+      def public_proxy = PUBLIC_ALIASES.fetch(proxy) { ActiveRecord::Base.public_method_defined?(proxy) ? proxy : nil }
+
+      def same_method?(other) = [proxy, attr, args] == [other.proxy, other.attr, other.args]
+    end
+
+    # What the index needs to know about one model; also what Manifest stores.
+    #   attributes: { "name" => :string, ... } (query kind, or nil)
+    #   patterns: [[prefix, suffix, proxy, takes_arguments], ...]
+    #   hand_written: generated-method names the model defines itself
+    #   superclass: the parent model's name, if it's a model
+    #   modules: the app's own modules among its ancestors (concerns)
+    #   associations: { "site" => ["Site", "one"], "items" => ["Item", "many"] }, not polymorphic
+    #   scopes: names defined with `scope` (they return relations of the model)
+    #   shadows: generated-method names of other models' attributes that this
+    #     model defines some other way (an enum predicate, a delegate, ...)
+    Model = Data.define(:name, :attributes, :primary_key, :patterns, :hand_written, :superclass, :modules, :associations, :scopes, :shadows) do
+      def initialize(superclass: nil, modules: [], associations: {}, scopes: [], shadows: [], **rest) = super
+    end
+
+    PUBLIC_ALIASES = { "attribute?" => "query_attribute" }.freeze
+
+    # query_attribute on a real column comes down to: true -> true, false/nil
+    # -> false, else !value.zero? if it has zero?, else !value.blank?. A
+    # column's type fixes which of those can happen. Decorated types (enums,
+    # time zone conversion, encrypts, serialize, normalizes) aren't listed and
+    # keep query_attribute.
+    QUERY = [
+      [ActiveModel::Type::Boolean, :truthy], # true, false, nil
+      [ActiveModel::Type::Date, :truthy], [ActiveModel::Type::DateTime, :truthy], [ActiveModel::Type::Time, :truthy],
+      [ActiveModel::Type::Integer, :numeric], [ActiveModel::Type::Float, :numeric], [ActiveModel::Type::Decimal, :numeric],
+      [ActiveModel::Type::ImmutableString, :string], # and String, Text
+    ].freeze
+
+    attr_reader :entries, :models, :keep
+
+    def self.from_models(models = ActiveRecord::Base.descendants, keep: Slim.keep || Slim::DEFAULT_KEEP)
+      new(describe_all(models), keep: keep)
+    end
+
+    def self.table?(model)
+      model.table_exists?
+    rescue StandardError
+      false
+    end
+
+    def self.describe(model)
+      attributes = model.attribute_names.to_h { [it, query_kind(model, it)] }
+      patterns = model.attribute_method_patterns.map { [it.prefix, it.suffix, it.proxy_target, it.parameters != false] }
+      names = patterns.flat_map { |prefix, suffix, _| attributes.keys.map { "#{prefix}#{it}#{suffix}" } }
+      parent = model.superclass
+      Model.new(name: constant_name(model), attributes: attributes, primary_key: Array(model.primary_key), patterns: patterns,
+        hand_written: names.select { hand_written?(model, it) }.sort,
+        superclass: (constant_name(parent) if parent < ActiveRecord::Base && !parent.abstract_class?),
+        modules: app_modules(model), associations: associations(model), scopes: scopes(model))
+    end
+
+    def self.associations(model)
+      model.reflect_on_all_associations.each_with_object({}) do |reflection, map|
+        next if reflection.polymorphic?
+
+        target = constant_name(reflection.klass)
+        map[reflection.name.to_s] = [target, reflection.collection? ? "many" : "one"] if target
+      rescue StandardError, NameError
+        nil
+      end.sort.to_h
+    end
+
+    # Class methods `scope` defined: on the model (or a parent model) itself,
+    # with ActiveRecord's scoping code as their source.
+    def self.scopes(model)
+      model.singleton_methods.select do |name|
+        method = model.method(name)
+        owner = method.owner
+        owner.singleton_class? && owner.attached_object.is_a?(Class) && model <= owner.attached_object &&
+          method.source_location&.first.to_s.end_with?("active_record/scoping/named.rb")
+      rescue StandardError
+        false
+      end.map(&:to_s).sort
+    end
+
+    # Named modules among the model's ancestors that the app defines (not gems
+    # or Ruby): the concerns whose methods run with a record as self.
+    def self.app_modules(model)
+      model.ancestors.take_while { !it.equal?(ActiveRecord::Base) }.filter_map do |mod|
+        next if mod.is_a?(Class) || !(name = constant_name(mod))
+
+        file = Module.const_source_location(name)&.first.to_s
+        name unless file.empty? || file.include?("/gems/") || file.start_with?(RbConfig::CONFIG["rubylibdir"])
+      rescue StandardError
+        nil
+      end.sort
+    end
+
+    # The name, if it leads back to the class: call-site guards reference it
+    # as a constant. HABTM join models all call themselves "HABTM_<Association>".
+    def self.constant_name(model)
+      name = model.name
+      name if name && Object.const_get(name).equal?(model)
+    rescue NameError
+      nil
+    end
+
+    # The compiled form of name? calls the reader, so it must be the generated one.
+    def self.query_kind(model, attr)
+      return if hand_written?(model, attr) || model.defined_enums.key?(attr)
+
+      type = model.type_for_attribute(attr)
+      QUERY.find { |klass, _| type.is_a?(klass) }&.last
+    end
+
+    def self.hand_written?(model, name)
+      return false unless model.method_defined?(name) || model.private_method_defined?(name)
+
+      !model.instance_method(name).owner.is_a?(ActiveRecord::AttributeMethods::GeneratedAttributeMethods)
+    end
+
+    def initialize(models, keep:)
+      @models = models.sort_by { it.name.to_s }.freeze
+      @keep = keep.map(&:to_s).sort.freeze
+      found = {} # name => [proxy, attr, args, classes, query]
+      poisoned = Set.new
+      @models.each do |model|
+        model.patterns.each do |prefix, suffix, proxy, args|
+          skip_all = @keep.include?(proxy)
+          model.attributes.each do |attr, query|
+            name = "#{prefix}#{attr}#{suffix}"
+            next if poisoned.include?(name)
+            next poisoned << name if skip_all || model.primary_key.include?(attr) || model.hand_written.include?(name)
+
+            query = nil unless proxy == "attribute?"
+            if (seen = found[name])
+              next poisoned << name unless seen[0] == proxy && seen[1] == attr && seen[2] == args
+
+              seen[3] << model.name if model.name
+              seen[4] = nil unless seen[4] == query
+            else
+              found[name] = [proxy, attr, args, model.name ? [model.name] : [], query]
+            end
+          end
+        end
+      end
+      @entries = found.each_with_object({}) do |(name, (proxy, attr, args, classes, query)), entries|
+        entries[name] = Entry.new(proxy, attr, args, classes.sort!.freeze, query) unless poisoned.include?(name)
+      end.freeze
+    end
+
+    def [](name) = @entries[name.to_s]
+
+    def model?(name) = by_name.key?(name)
+
+    def app_module?(name) = includers.key?(name)
+
+    # The model and every model below it.
+    def with_descendants(name)
+      @with_descendants ||= {}
+      @with_descendants[name] ||= begin
+        children = @models.select { it.superclass == name }.map(&:name)
+        ([name] + children.flat_map { with_descendants(it) }).uniq.freeze
+      end
+    end
+
+    # [class name, "one" or "many"] for model#name, or nil.
+    def association(model, name) = by_name[model]&.associations&.[](name.to_s)
+
+    def scope?(model, name) = by_name[model]&.scopes&.include?(name.to_s) || false
+
+    # Models (and their subclasses) that include the module.
+    def includers_of(name) = includers.fetch(name, [])
+
+    # Would the entry's method on any of these classes be the generated one?
+    def covers?(entry, classes) = classes.all? { entry.classes.include?(it) }
+
+    def ==(other) = other.is_a?(Index) && entries == other.entries
+
+    # Same input, same index: what Manifest stores and compares.
+    def self.describe_all(models = ActiveRecord::Base.descendants)
+      described = models.reject { it.abstract_class? || !table?(it) }.to_h { [it, describe(it)] }
+      generated = described.values.flat_map { |m| m.patterns.flat_map { |prefix, suffix, _| m.attributes.keys.map { "#{prefix}#{it}#{suffix}" } } }.uniq
+      described.map do |model, m|
+        own = m.patterns.flat_map { |prefix, suffix, _| m.attributes.keys.map { "#{prefix}#{it}#{suffix}" } }.to_set
+        shadows = generated.select { !own.include?(it) && (model.method_defined?(it) || model.private_method_defined?(it)) && !ActiveRecord::Base.method_defined?(it) }
+        shadows.empty? ? m : m.with(shadows: shadows.sort)
+      end
+    end
+
+    # Models that define name without it being their attribute method.
+    def shadowed(name)
+      @shadowed ||= @models.each_with_object({}) { |m, map| m.shadows.each { (map[it] ||= []) << m.name } }
+      @shadowed.fetch(name.to_s, [])
+    end
+
+    def size = @entries.size
+
+    private
+
+    def by_name = @by_name ||= @models.to_h { [it.name, it] }
+
+    def includers
+      @includers ||= @models.each_with_object(Hash.new { |h, k| h[k] = [] }) do |model, map|
+        model.modules.each { map[it] |= with_descendants(model.name) }
+      end
+    end
+  end
+end

data/lib/ar_minimizer/loader.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ArMinimizer
+  # Compiles each matching file as Ruby loads it, instead of Build rewriting
+  # files in place, the way ruby-next's runtime mode works: through
+  # require-hooks, which also makes bootsnap cache the compiled result. The
+  # bootsnap cache key includes the manifest digest, so a new manifest
+  # recompiles everything.
+  #
+  #   config.ar_minimizer.load_time = true   # needs config/ar_minimizer.json
+  module Loader
+    class << self
+      # index: an Index, or something that returns one when called: with a
+      # warm bootsnap cache nothing gets compiled and the index is never needed.
+      # version: changes when the index does (Manifest.digest of the file).
+      def install!(index:, patterns:, exclude_patterns: nil, version: nil, guards: false)
+        require "require-hooks/setup"
+        @index = index
+        @guards = guards
+        @mutex = Mutex.new
+        if defined?(RequireHooks::Bootsnap) && RequireHooks::Bootsnap.respond_to?(:add_version_hash)
+          RequireHooks::Bootsnap.add_version_hash("ar_minimizer-#{version || Manifest.digest(self.index)}-guards-#{guards}")
+        end
+        RequireHooks.source_transform(patterns: patterns, exclude_patterns: exclude_patterns) do |path, source|
+          Loader.transform(path, source)
+        end
+      end
+
+      def index
+        return @index unless @index.respond_to?(:call)
+
+        @mutex.synchronize { @index = @index.call if @index.respond_to?(:call) }
+        @index
+      end
+
+      # nil leaves the file as it is.
+      def transform(path, source)
+        result = Rewriter.new(index: index, path: path, marker: false, guards: @guards).rewrite(source || File.read(path))
+        result.source if result.sites.positive?
+      end
+    end
+  end
+end