rails2qdbd 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5b17ebb700917652e2ac95acd51f4e478739d75c4c4a9bc23d75268498e2cd04
+  data.tar.gz: 9e9185d57c57e0cb3602ce000e0a60a72ec558d48acca7fe28b6af75b8a82c19
+SHA512:
+  metadata.gz: 6ecab2033502484b369de176755ddffcf013968803dec56b3c9e92470457279492c9eb9495fb83e4503b34a82318b08f4ea7196aa5b8686b08cf7e99810e3df4
+  data.tar.gz: 73f8b2ef9607de0fcf17b7d29924e323dcbeb77e3c722630a2a9aaa0c9d060518f4f7baa17a6855f12e9a004e538001d2325a670fccc289e2be291c47541ac90

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
+[Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-26
+
+### Added
+- Converter: `db/schema.rb` (+ extra schema files) and `app/models` → qdbd schema files,
+  parsed statically with Prism.
+- Relationships from `add_foreign_key` / `t.references` and from `belongs_to`, `has_many`,
+  `has_one`, `has_and_belongs_to_many` (class_name, foreign_key, primary_key, join_table,
+  STI, concerns, `with_options`, namespaces, project inflections).
+- Documentation notes for composite/expression/partial indexes, check constraints, enums,
+  polymorphic associations (incl. Active Storage), generated columns, STI, attachments.
+- `.rails2qdbd.yml`: output, schemas, models, inflections, exclude, groups.
+- CLI `rails2qdbd` with `--check` for CI.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fastcatch
+
+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,161 @@
+# rails2qdbd
+
+Turn a Rails application's `db/schema.rb` and `app/models` into
+[qdbd](https://qdbd.dev/guide/) schema files: plain-text QuickDBD syntax that
+qdbd checks, lays out and serves as an interactive ER diagram.
+
+```sh
+rails2qdbd path/to/app -o schema/     # write schema/*.txt
+qdbd serve schema/                    # live diagram in the browser
+```
+
+- Ruby files are parsed with [Prism](https://github.com/ruby/prism),
+  never executed. No app boot, no database, none of the app's gems needed.
+- Relationships come from database foreign keys and from model
+  associations (`belongs_to`, `has_many`, `has_one`, `has_and_belongs_to_many`,
+  STI, concerns, namespaces, project inflections).
+- What qdbd cannot draw (composite, expression and
+  partial indexes, enums, polymorphic associations, generated columns,
+  check constraints, attachments) becomes documentation that qdbd shows on hover.
+  Anything the tool cannot resolve is reported as a warning.
+- Output is deterministic, and `--check` exits 1 when the
+  committed files are stale.
+
+## Installation
+
+```sh
+gem install rails2qdbd
+```
+
+or in the app's Gemfile (it never loads into the app; it only reads files):
+
+```ruby
+gem "rails2qdbd", group: :development, require: false
+```
+
+Requirements: Ruby ≥ 3.2 (tested on 3.2 – 4.0), with `prism` and
+`activesupport` ≥ 7.1 as its only runtime dependencies, so it fits Rails 7.1 –
+8.1 apps. To look at the result you need
+[qdbd](https://pypi.org/project/quickdbd-cli/) (`pipx install quickdbd-cli`).
+
+## Usage
+
+```
+rails2qdbd [APP_ROOT] [options]          # APP_ROOT defaults to "."
+  -o, --output PATH     a .txt file or a directory (default: config, else stdout)
+      --schema FILE     schema file, repeatable (default: db/schema.rb)
+      --models DIR      models directory (default: app/models)
+      --no-models       schema only, no model associations
+  -c, --config FILE     config file (default: APP_ROOT/.rails2qdbd.yml)
+      --exclude GLOB    leave out matching tables, repeatable
+      --check           write nothing; exit 1 if the output is out of date
+  -q, --quiet           no warnings or summary
+  -v, --version
+```
+
+Paths on the command line are relative to the current directory; paths in the
+config file are relative to the app root. Exit codes: `0` ok, `1` errors or
+out of date, `2` usage error. Warnings go to stderr as
+`path:line: warning: message`.
+
+Multiple databases (Rails 8's `db/queue_schema.rb`, `db/cache_schema.rb`, …)
+can be combined: `--schema db/schema.rb --schema db/queue_schema.rb`.
+
+### Configuration: `.rails2qdbd.yml`
+
+Optional, in the app root:
+
+```yaml
+output: schema/                 # .txt file or directory
+schemas: [db/schema.rb]
+models: app/models              # false: schema only
+inflections: config/initializers/inflections.rb   # false: ignore
+exclude: [ar_internal_metadata, "solid_*"]
+default_group: app
+groups:                         # one file per group (qdbd shows each file as a group)
+  storage: ["active_storage_*"]
+  auth: [users, sessions]
+```
+
+Groups split the output into one file per group when the output is a
+directory; the first matching glob wins. Without groups, or with a `.txt`
+output, everything goes into one file.
+
+### Keeping the diagram current in CI
+
+```sh
+rails2qdbd -o schema/ --check && qdbd check --strict schema/
+```
+
+Generated files begin with `# Generated by rails2qdbd …`. Only files with
+that header are ever replaced or deleted, so hand-written qdbd files can live
+alongside them; if an output file exists without it, nothing is written and the
+command exits 1. qdbd's layout file (`qdbd.layout.json`) is
+never touched, so table positions you arrange are kept across regenerations.
+
+## What you get
+
+```text
+# unique index (tenant_id, email_address)
+users
+-
+id PK bigint
+email_address string
+invalidated_at datetime NULL
+# enum: member, owner
+role string default=member
+tenant_id bigint INDEX FK >- tenants.id
+```
+
+| Rails | qdbd |
+|---|---|
+| implicit `id`, `id: :uuid`, `primary_key: "code"`, composite `primary_key: [...]`, `id: false` | `PK` on the key column(s) |
+| column type and `limit:` / `precision:` / `scale:` / `array:` | `string(50)`, `decimal(10,2)`, `string[]` (Rails type names) |
+| nullable (Rails default) | `NULL` (qdbd's default is NOT NULL) |
+| `default:` (including `-> { "now()" }`) | `default=…`, quoted when needed |
+| single-column unique / plain index | `UNIQUE` / `INDEX` |
+| composite, expression, partial index; index on one column of a composite primary key; `check_constraint` | documentation line above the table |
+| `add_foreign_key`, `t.references foreign_key: true` | `FK >- table.column` |
+| association without a database FK | `FK >- …` plus the note *relationship from model association* |
+| unique FK column, or `has_one` (without `has_many`) | one-to-one `FK - …` |
+| `has_and_belongs_to_many` | FKs on the join table |
+| polymorphic `belongs_to` / `has_many as:` / Active Storage | note: `polymorphic (type in x_type): Model, …` |
+| `enum` (model) / `create_enum` (PostgreSQL) | note: `enum: a, b` |
+| `t.virtual … as:` | note: `generated: …` |
+| STI subclasses, `has_*_attached` | table notes |
+| `comment:` on tables and columns | documentation lines |
+
+## Limitations
+
+- `db/structure.sql` is not read (use `schema.rb`).
+- Association options must be literals; `class_name: some_method` is skipped
+  with a warning.
+- Relationships are never guessed from column names alone.
+- Module-level `table_name_prefix` is not followed; use `self.table_name`.
+- Only the literal `irregular / plural / singular / uncountable / acronym`
+  calls of `config/initializers/inflections.rb` are applied.
+
+## Development
+
+```sh
+bin/setup                 # gems into .bundle/, qdbd into .venv/; nothing installed globally
+bundle exec rake test     # unit + integration tests (qdbd checks skip if qdbd is missing;
+                          # REQUIRE_QDBD=1 makes them fail instead, as in CI)
+bundle exec rake golden   # regenerate test/fixtures/apps/*/expected after an intended output change
+bundle exec exe/rails2qdbd --help
+```
+
+Tests are written first (Minitest). `test/fixtures/apps/shop` is a synthetic
+app covering every supported feature; its golden output is validated with
+`qdbd check --strict`, and qdbd's own parser is used to assert what qdbd
+understood. CI ([workflow](.github/workflows/ci.yml)) runs Ruby 3.3 – 4.0 on
+the locked dependencies and Ruby 3.2 on the oldest allowed ones
+(`gemfiles/minimum.gemfile`).
+
+Releases are published to RubyGems.org by the
+[release workflow](.github/workflows/release.yml) when a `vX.Y.Z` tag matching
+`Rails2qdbd::VERSION` is pushed.
+
+## License
+
+MIT

data/exe/rails2qdbd

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rails2qdbd"
+
+exit Rails2qdbd::CLI.new(ARGV).run

data/lib/rails2qdbd/catalog.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Rails2qdbd
+  # The intermediate representation shared by every stage. It knows neither Rails
+  # nor qdbd syntax, so new sources (structure.sql, live reflection) and new writers
+  # can plug in without touching the rest.
+  module Catalog
+    # Struct with keyword arguments and per-member defaults (procs build fresh objects).
+    def self.record(*members, **defaults, &body)
+      Struct.new(*members, keyword_init: true) do
+        define_method(:initialize) do |**attrs|
+          unknown = attrs.keys - members
+          raise ArgumentError, "unknown keywords: #{unknown.join(', ')}" if unknown.any?
+
+          values = defaults.to_h { |key, value| [key, value.respond_to?(:call) ? value.call : value] }
+          super(**values, **attrs)
+        end
+        class_eval(&body) if body
+      end
+    end
+
+    Column = record(:name, :type, :null, :default, :limit, :precision, :scale, :array, :comment,
+                    :generated, :enum_values, null: true, array: false)
+
+    Index = record(:columns, :expression, :unique, :where, :name, columns: -> { [] }, unique: false) do
+      # Only these can be expressed with qdbd's column keywords (UNIQUE / INDEX).
+      def single_column?
+        columns.size == 1 && expression.nil? && where.nil?
+      end
+    end
+
+    # checks: check-constraint expressions, kept as documentation.
+    Table = record(:name, :columns, :primary_key, :indexes, :checks, :comment, :path, :line,
+                   columns: -> { [] }, primary_key: -> { [] }, indexes: -> { [] }, checks: -> { [] }) do
+      def column(name)
+        columns.find { |column| column.name == name }
+      end
+
+      def index_on(column_name)
+        indexes.find { |index| index.single_column? && index.columns.first == column_name }
+      end
+    end
+
+    ForeignKey = record(:from_table, :from_column, :to_table, :to_column)
+
+    Schema = record(:tables, :foreign_keys, :enums, :version,
+                    tables: -> { {} }, foreign_keys: -> { [] }, enums: -> { {} })
+
+    Association = record(:macro, :name, :options, :path, :line, options: -> { {} })
+
+    # primary_key: a column name, or an Array for a composite key.
+    Model = record(:name, :superclass, :abstract, :table_name, :primary_key, :associations, :enums,
+                   :attachments, :includes, :path, :line,
+                   abstract: false, associations: -> { [] }, enums: -> { {} }, attachments: -> { [] },
+                   includes: -> { [] })
+
+    # cardinality: :many_to_one or :one_to_one; source: :database or :model.
+    Relationship = record(:from_table, :from_column, :to_table, :to_column, :cardinality, :source,
+                          cardinality: :many_to_one)
+
+    Diagnostic = record(:severity, :message, :path, :line, severity: :warning) do
+      def to_s
+        location = [path, line].compact.join(":")
+        location.empty? ? "#{severity}: #{message}" : "#{location}: #{severity}: #{message}"
+      end
+    end
+  end
+end

data/lib/rails2qdbd/cli.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Rails2qdbd
+  # `rails2qdbd [APP_ROOT] [options]`. Exit codes: 0 ok,
+  # 1 errors or out of date (--check), 2 usage error. Paths given here are relative to cwd.
+  class CLI
+    def initialize(argv, out: $stdout, err: $stderr, cwd: Dir.pwd)
+      @argv = argv.dup
+      @out = out
+      @err = err
+      @cwd = cwd
+      @overrides = {}
+    end
+
+    def run
+      parser = option_parser
+      args = parser.parse(@argv)
+      return 0 if @done
+
+      app_root = File.expand_path(args.first || ".", @cwd)
+      config = Config.load(app_root, path: @config_path, overrides: @overrides)
+      result = Converter.new(config).run
+      report(result.diagnostics)
+      return 1 if result.diagnostics.any? { |d| d.severity == :error }
+
+      deliver(result, config)
+    rescue OptionParser::ParseError => e
+      @err.puts "rails2qdbd: #{e.message}", parser.banner
+      2
+    rescue Error => e
+      @err.puts "rails2qdbd: #{e.message}"
+      1
+    end
+
+    private
+
+    def option_parser
+      OptionParser.new do |o|
+        o.banner = "Usage: rails2qdbd [APP_ROOT] [options]"
+        o.separator "Converts db/schema.rb and app/models into qdbd schema files (APP_ROOT defaults to .)."
+        o.on("-o", "--output PATH", "a .txt file or a directory (default: config, else stdout)") { |v| @overrides[:output] = path(v) }
+        o.on("--schema FILE", "schema file, repeatable (default: db/schema.rb)") { |v| (@overrides[:schemas] ||= []) << path(v) }
+        o.on("--models DIR", "models directory (default: app/models)") { |v| @overrides[:models] = path(v) }
+        o.on("--no-models", "schema only, no model associations") { @overrides[:models] = false }
+        o.on("-c", "--config FILE", "config file (default: APP_ROOT/.rails2qdbd.yml)") { |v| @config_path = path(v) }
+        o.on("--exclude GLOB", "leave out matching tables, repeatable") { |v| (@overrides[:exclude] ||= []) << v }
+        o.on("--check", "write nothing; exit 1 if the output is out of date") { @check = true }
+        o.on("-q", "--quiet", "no warnings or summary") { @quiet = true }
+        o.on("-v", "--version", "print the version") { finish("rails2qdbd #{VERSION}") }
+        o.on("-h", "--help", "print this help") { finish(o.help) }
+      end
+    end
+
+    def finish(text)
+      @out.puts text
+      @done = true
+    end
+
+    def path(value) = File.expand_path(value, @cwd)
+
+    def report(diagnostics)
+      diagnostics.each { |d| @err.puts d.to_s if d.severity == :error || !@quiet }
+    end
+
+    def deliver(result, config)
+      output = config.output && File.expand_path(config.output, config.app_root)
+      return check(result, output) if @check
+      unless output
+        @out.print(result.files.values.join("\n"))
+        return 0
+      end
+
+      written = Output.write(result, output)
+      unless @quiet
+        @out.puts "wrote #{written.size} file(s) to #{output}: #{result.tables} tables, " \
+                  "#{result.relationships} relationship#{'s' unless result.relationships == 1}"
+      end
+      0
+    end
+
+    def check(result, output)
+      unless output
+        @err.puts "rails2qdbd: --check needs an output path (-o, or output: in the config)"
+        return 2
+      end
+
+      problems = Output.stale(result, output)
+      problems.each { |problem| @err.puts "out of date: #{problem}" }
+      @out.puts "up to date" if problems.empty?
+      problems.empty? ? 0 : 1
+    end
+  end
+end

data/lib/rails2qdbd/config.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Rails2qdbd
+  # Settings from .rails2qdbd.yml (or --config), overridden by command-line options.
+  # Paths are relative to the app root.
+  class Config
+    FILE = ".rails2qdbd.yml"
+    DEFAULTS = {
+      output: nil,
+      schemas: ["db/schema.rb"],
+      models: "app/models",
+      inflections: "config/initializers/inflections.rb",
+      exclude: [],
+      default_group: "app",
+      groups: {},
+    }.freeze
+
+    attr_reader :app_root, :path, *DEFAULTS.keys
+
+    # overrides: same keys as the file; :exclude adds to the file's list instead of replacing it.
+    def self.load(app_root, path: nil, overrides: {})
+      if path
+        raise Error, "config file not found: #{path}" unless File.file?(File.expand_path(path, app_root))
+      elsif File.file?(File.join(app_root, FILE))
+        path = FILE
+      end
+      values = path ? read(File.expand_path(path, app_root), path) : {}
+      new(app_root, path, values, overrides)
+    end
+
+    def self.read(full_path, label)
+      data = YAML.safe_load_file(full_path) || {}
+      raise Error, "#{label} must be a mapping of settings" unless data.is_a?(Hash)
+
+      data.transform_keys(&:to_sym).tap do |values|
+        unknown = values.keys - DEFAULTS.keys
+        raise Error, "unknown config key in #{label}: #{unknown.join(', ')}" if unknown.any?
+        unless values[:groups].nil? || values[:groups].is_a?(Hash)
+          raise Error, "groups in #{label} must map group names to table globs"
+        end
+      end
+    rescue Psych::Exception => e
+      raise Error, "#{label}: invalid YAML (#{e.message})"
+    end
+
+    def initialize(app_root, path, values, overrides)
+      @app_root = app_root
+      @path = path
+      settings = DEFAULTS.merge(values.compact).merge(overrides.except(:exclude).compact)
+      @output = settings[:output]
+      @schemas = Array(settings[:schemas]).map(&:to_s)
+      @models = settings[:models] == false ? false : settings[:models].to_s
+      @inflections = settings[:inflections] == false ? false : settings[:inflections].to_s
+      @exclude = (Array(settings[:exclude]) + Array(overrides[:exclude])).map(&:to_s)
+      @default_group = settings[:default_group].to_s
+      @groups = settings[:groups].to_h { |name, globs| [name.to_s, Array(globs).map(&:to_s)] }
+    end
+  end
+end

data/lib/rails2qdbd/converter.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Rails2qdbd
+  # Runs the whole pipeline for one app: inflections -> schema -> models -> resolver -> writer.
+  class Converter
+    # files: { "name.txt" => text }; tables/relationships: counts for the CLI summary.
+    Result = Struct.new(:files, :diagnostics, :tables, :relationships, keyword_init: true)
+
+    SINGLE_FILE = "schema.txt"
+
+    def initialize(config)
+      @config = config
+      @root = config.app_root
+      @grouping = Grouping.new(config)
+    end
+
+    def run
+      @diagnostics = []
+      inflector = load_inflector
+      parser = SchemaParser.new(inflector: inflector)
+      schemas = @config.schemas.map { |path| relative(path) }
+      schema = parser.parse_files(schemas, root: @root)
+      @diagnostics.concat(parser.diagnostics)
+      models = scan_models
+      resolver = Resolver.new(schema, models || {}, inflector: inflector, excluded: ->(table) { @grouping.excluded?(table) })
+      resolution = resolver.resolve
+      @diagnostics.concat(resolution.diagnostics)
+
+      tables = schema.tables.values.reject { |table| @grouping.excluded?(table.name) }.sort_by(&:name)
+      inputs = schemas + (models ? [relative(@config.models)] : [])
+      Result.new(files: render(tables, resolution, inputs), diagnostics: @diagnostics, tables: tables.size,
+                 relationships: resolution.relationships.size)
+    end
+
+    private
+
+    def load_inflector
+      inflector = Inflector.new
+      path = @config.inflections
+      if path && File.file?(full = File.expand_path(path, @root))
+        @diagnostics.concat(inflector.apply_file(File.read(full), path: path))
+      end
+      inflector
+    end
+
+    # nil when model scanning is off or there is no models directory.
+    def scan_models
+      return nil unless @config.models
+
+      dir = File.expand_path(@config.models, @root)
+      unless File.directory?(dir)
+        @diagnostics << Catalog::Diagnostic.new(
+          message: "models directory not found: #{@config.models} (relationships come from the schema only)",
+        )
+        return nil
+      end
+
+      sources = Dir.glob("**/*.rb", base: dir).sort.to_h do |file|
+        [File.join(relative(@config.models), file), File.read(File.join(dir, file))]
+      end
+      scanner = ModelScanner.new
+      scanner.scan(sources: sources).tap { @diagnostics.concat(scanner.diagnostics) }
+    end
+
+    # Paths inside the app are shown relative to it, so output does not depend on the cwd.
+    def relative(path)
+      full = Pathname(File.expand_path(path, @root))
+      inside = full.relative_path_from(Pathname(File.expand_path(@root))).to_s
+      inside.start_with?("..") ? path : inside
+    end
+
+    def render(tables, resolution, inputs)
+      writer = Writer.new
+      by_file = tables.group_by { |table| file_for(table) }
+      # No tables still gives a headed file, so the output exists and --check has something to compare.
+      by_file = { SINGLE_FILE => [] } if by_file.empty?
+      by_file.sort.to_h do |file, file_tables|
+        texts = file_tables.map do |table|
+          writer.render_table(table, relationships: resolution.relationships,
+                                     table_notes: resolution.table_notes.fetch(table.name, []),
+                                     column_notes: resolution.column_notes.fetch(table.name, {}))
+        end
+        [file, writer.render_file(tables_text: texts, inputs: inputs)]
+      end
+    end
+
+    # One file per group only when groups are configured and the output is a directory.
+    def file_for(table)
+      output = @config.output
+      split = @config.groups.any? && output && !output.end_with?(".txt")
+      split ? "#{@grouping.group_for(table.name)}.txt" : SINGLE_FILE
+    end
+  end
+end

data/lib/rails2qdbd/grouping.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rails2qdbd
+  # Assigns tables to output files (qdbd shows each file as a group) and applies excludes.
+  class Grouping
+    GLOB_FLAGS = File::FNM_EXTGLOB
+
+    def initialize(config)
+      @config = config
+    end
+
+    # The first group with a matching glob, else the default group.
+    def group_for(table)
+      @config.groups.find { |_, globs| matches?(globs, table) }&.first || @config.default_group
+    end
+
+    def excluded?(table) = matches?(@config.exclude, table)
+
+    private
+
+    def matches?(globs, table) = globs.any? { |glob| File.fnmatch?(glob, table, GLOB_FLAGS) }
+  end
+end

data/lib/rails2qdbd/inflector.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "prism"
+require "active_support/inflector"
+
+module Rails2qdbd
+  # ActiveSupport's inflector over a private copy of the English rules, so a project's own
+  # inflections apply to this conversion only and the global inflector is never mutated.
+  class Inflector
+    include ActiveSupport::Inflector
+
+    RULES = %i[irregular plural singular uncountable acronym].freeze
+
+    def initialize
+      english = ActiveSupport::Inflector.inflections(:en)
+      @inflections = english.dup
+      # Inflections#dup shares the uncountables' word list with the original; rebuild it so
+      # `uncountable` here cannot leak into the global inflector.
+      @inflections.clear(:uncountables)
+      @inflections.uncountable(english.uncountables.to_a)
+    end
+
+    # Every ActiveSupport::Inflector method looks its rules up through here.
+    def inflections(_locale = :en)
+      block_given? ? yield(@inflections) : @inflections
+    end
+
+    # Rails table names come from the demodulized class name (Admin::User -> users).
+    def tableize(class_name) = pluralize(underscore(demodulize(class_name.to_s)))
+
+    # Applies the literal inflection rules of config/initializers/inflections.rb without
+    # executing it. Returns warnings for everything it skipped.
+    def apply_file(source, path:)
+      diagnostics = []
+      result = Prism.parse(source)
+      return [Catalog::Diagnostic.new(severity: :warning, message: "syntax error, inflections ignored", path: path)] if result.failure?
+
+      each_call(result.value) do |call|
+        next unless call.receiver.is_a?(Prism::LocalVariableReadNode)
+
+        message = apply_rule(call)
+        diagnostics << Catalog::Diagnostic.new(message: message, path: path, line: call.location.start_line) if message
+      end
+      diagnostics
+    end
+
+    private
+
+    # nil when applied, else the reason it was skipped.
+    def apply_rule(call)
+      return "inflection `#{call.name}` ignored" unless RULES.include?(call.name)
+
+      args = (call.arguments&.arguments || []).map { |node| Literal.value(node) }
+      return "inflection `#{call.name}` with non-literal arguments ignored" unless args.all? { |arg| Literal.known?(arg) }
+
+      @inflections.public_send(call.name, *args)
+      nil
+    end
+
+    def each_call(node, &block)
+      yield node if node.is_a?(Prism::CallNode)
+      node.compact_child_nodes.each { |child| each_call(child, &block) }
+    end
+  end
+end