exwiw 0.3.8 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90a440a039497562ccc9a4ab3045342953ba23faf0fdff48cfd633771a4688a4
-  data.tar.gz: 5f8ee4853cbbe39dedba4176e5db61d91572ee3766d1d76e3eda6977ea373e6b
+  metadata.gz: ea6a0b4fda446d66766027139136320937a59319bfe28d83ee595cf062a4023a
+  data.tar.gz: 1ce3d4a7601ae6b3f1fe6ca8ed22e977389ac7ab46973c33113206911893326e
 SHA512:
-  metadata.gz: aa34168f0c3b6137eca95bf8ebeea625ea106559a779bd8739c09e5ab8ffeae0a9a84f9ca188809e579ab3d1c3f8c77b68d57d006b156de30b1d01e100435ecb
-  data.tar.gz: c7ad4547852032fcb4c356883232c8a34d6418baf498686ed6f25a80279d1cf61379b566ee29267f989d9de80f4b2490022d03695e686dedf5c506b2c01871f8
+  metadata.gz: '08ffcb1713110629652b4047b159613ab3d13e5fffcd092433282f28564328d1609572d8f159b1c0e7fddfab1be4fc92651b8f819ddfa44a913e18da04e4aeef'
+  data.tar.gz: 77529a1897ded0943898f60d8a55d54bfdf35f80fc512b57be7300adad9fc8c99767199de8e6d9fb9649dc2644fbcfc2252e445de2f5c38bc20aece5ae4a56d5

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.3.9] - 2026-06-03
+
+### Added
+
+- New `exwiw:schema:tidy` rake task. It reconciles the existing schema config against the live database (read through the database connection, not the models) and removes only what no longer exists there: a config file whose table has been dropped is deleted, and columns recorded in a surviving table's config that the table no longer has are dropped from that file. Because it reads the database directly, a table that still exists in the database but has lost (or never had) a model is kept — only a genuinely-dropped table is removed. Unlike `schema:generate` it never adds or regenerates entries, so hand-edited `comment` / `ignore` / `replace_with` on surviving tables/columns are preserved. It honors `OUTPUT_DIR_PATH` and the per-database subdirectory layout, and prints the tables/columns it removed.
+
 ## [0.3.8] - 2026-06-02
 
 ### Added

data/README.md

@@ -144,6 +144,23 @@ By default, the schema files will be saved in the `exwiw` directory. You can spe
 OUTPUT_DIR_PATH=custom_directory bundle exec rake exwiw:schema:generate
 ```
 
+#### Tidying stale config (`schema:tidy`)
+
+`schema:generate` adds and updates config files for the tables it finds, but it never deletes the config file of a table that has been dropped from the application. To reconcile the existing config against the current schema, run:
+
+```bash
+bundle exec rake exwiw:schema:tidy
+```
+
+`schema:tidy` compares the config files already on disk with the **live database** (read through the database connection, not the models) and removes only what no longer exists there:
+
+- a config file whose table has been dropped from the database is **deleted**, and
+- columns recorded in a surviving table's config that the table no longer has are **dropped** from that file.
+
+Because it reads the database directly, a table that still exists in the database but has lost (or never had) an ActiveRecord model is **kept** — only a table that is genuinely gone is removed. (This is the deliberate counterpart to `generate`, which is model-driven and only ever adds what the models know about.)
+
+It respects `OUTPUT_DIR_PATH` and the per-database subdirectory layout in the same way as `schema:generate`. Unlike `generate`, `tidy` never adds or regenerates entries — every surviving table/column (including hand-edited `comment` / `ignore` / `replace_with`) is left untouched, so it is safe to run on a customized config. The task prints which tables and columns it removed (or that the config was already tidy). Stale `belongs_tos` are not pruned by `tidy`; rerun `schema:generate` to refresh those.
+
 #### Multiple databases
 
 If the application uses Rails' multiple-database support (`connects_to`), `schema:generate` buckets models by the database they connect to and writes each database's config files into its own subdirectory of the output directory, named after the database config name (`primary`, `analytics`, ...):

data/lib/exwiw/schema_generator.rb

@@ -5,6 +5,30 @@ require "json"
 
 module Exwiw
   class SchemaGenerator
+    # Summary of what `SchemaGenerator#tidy!` removed, returned so callers can
+    # report it. `removed_columns` maps a surviving table's name to the column
+    # names that were dropped from its config.
+    class TidyResult
+      attr_reader :removed_tables, :removed_columns
+
+      def initialize
+        @removed_tables = []
+        @removed_columns = {}
+      end
+
+      def add_removed_table(table_name)
+        @removed_tables << table_name
+      end
+
+      def add_removed_column(table_name, column_name)
+        (@removed_columns[table_name] ||= []) << column_name
+      end
+
+      def empty?
+        @removed_tables.empty? && @removed_columns.empty?
+      end
+    end
+
     # ActiveStorage tracks generated image variants in this table. Its rows are
     # derivative and regenerable — ActiveStorage lazily (re)creates a variant the
     # next time it is requested — so there is little value in exporting them. More
@@ -35,6 +59,60 @@ module Exwiw
       groups
     end
 
+    # Reconcile the config files already on disk against the live database,
+    # removing only what no longer exists there:
+    #
+    # - a config file whose table is no longer present is deleted, and
+    # - columns recorded in a surviving table's config that the table no
+    #   longer has are dropped from that file.
+    #
+    # The source of truth is the database connection (`data_sources` for table
+    # existence — which covers views too — and `columns` for the column list),
+    # NOT `build_table_groups`. `build_table_groups` only knows about tables
+    # that still have an ActiveRecord model, so reconciling against it would
+    # delete the config of a table that is still present in the database but
+    # has merely lost (or never had) a model. Reading the connection directly
+    # avoids that: only a table that is genuinely gone from the database is
+    # removed.
+    #
+    # Unlike `generate!`, tidy never adds or regenerates entries: every
+    # surviving table/column — including its hand-edited `comment` / `ignore` /
+    # `replace_with` — is left untouched, and only the stale entries are
+    # stripped. (Removing a deleted column is something `generate!` already does
+    # incidentally via #merge, but `generate!` can never delete the config file
+    # of a removed table, which is the gap this fills.) Returns a TidyResult
+    # describing the removals so callers (e.g. the rake task) can report them.
+    def tidy!
+      result = TidyResult.new
+
+      model_db_groups.each do |db_name, _group_models, conn|
+        dir = config_dir_for(db_name)
+        next unless Dir.exist?(dir)
+
+        existing_data_sources = conn.data_sources.to_set
+
+        Dir[File.join(dir, "*.json")].sort.each do |path|
+          existing = TableConfig.from(JSON.parse(File.read(path)))
+
+          unless existing_data_sources.include?(existing.name)
+            File.delete(path)
+            result.add_removed_table(existing.name)
+            next
+          end
+
+          valid_column_names = conn.columns(existing.name).map(&:name).to_set
+          stale_columns = existing.columns.reject { |column| valid_column_names.include?(column.name) }
+          next if stale_columns.empty?
+
+          existing.columns = existing.columns.select { |column| valid_column_names.include?(column.name) }
+          File.write(path, JSON.pretty_generate(existing.to_hash) + "\n")
+          stale_columns.each { |column| result.add_removed_column(existing.name, column.name) }
+        end
+      end
+
+      result
+    end
+
     # Returns a Hash keyed by the database name.
     #
     # - Single-database setup: the only key is `nil`, signalling that the table
@@ -44,18 +122,35 @@ module Exwiw
     #   mapping to that database's table configs. They are written into
     #   `output_dir/<db_name>/`.
     def build_table_groups
+      model_db_groups.each_with_object({}) do |(db_name, group_models, conn), result|
+        result[db_name] = build_tables_for(group_models, conn)
+      end
+    end
+
+    # The per-database grouping that both `build_table_groups` and `tidy!` work
+    # from: `[[db_name, models, connection], ...]`.
+    #
+    # - Single-database setup: one entry keyed by `nil` (configs written flat
+    #   into `output_dir`). When there are no models at all, fall back to the
+    #   default connection so callers still have a connection to inspect.
+    # - Multi-database setup (Rails `connects_to`): one entry per database,
+    #   keyed by `connection_db_config.name` ("primary" / "analytics", ...).
+    #
+    # The db_name <-> connection mapping is necessarily model-derived: which
+    # databases the app talks to is only declared on the model side (via
+    # `connects_to`). What each consumer reads *through* that connection differs
+    # — `build_table_groups` builds configs from the models, while `tidy!`
+    # reads the live database's actual tables/columns.
+    private def model_db_groups
       models = concrete_models
       grouped = models.group_by { |model| database_name_for(model) }
 
       if grouped.size <= 1
         conn = models.empty? ? ActiveRecord::Base.connection : models.first.connection
-        return { nil => build_tables_for(models, conn) }
+        return [[nil, models, conn]]
       end
 
-      grouped.each_with_object({}) do |(db_name, group_models), result|
-        conn = group_models.first.connection
-        result[db_name] = build_tables_for(group_models, conn)
-      end
+      grouped.map { |db_name, group_models| [db_name, group_models, group_models.first.connection] }
     end
 
     # Backwards-compatible flat list of all table configs. Only meaningful for
@@ -67,11 +162,18 @@ module Exwiw
 
     def write_groups(groups)
       groups.each do |db_name, tables|
-        dir = db_name.nil? ? @output_dir : File.join(@output_dir, db_name)
-        write_files(dir, tables)
+        write_files(config_dir_for(db_name), tables)
       end
     end
 
+    # The directory a database group's config files live in. A single-database
+    # setup (`db_name` is nil) writes flat into `output_dir`; a multi-database
+    # setup writes into `output_dir/<db_name>/`. Shared by `write_groups` and
+    # `tidy!` so the two operations agree on file locations.
+    private def config_dir_for(db_name)
+      db_name.nil? ? @output_dir : File.join(@output_dir, db_name)
+    end
+
     def write_files(dir, tables)
       FileUtils.mkdir_p(dir)
 

data/lib/exwiw/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Exwiw
-  VERSION = "0.3.8"
+  VERSION = "0.3.9"
 end

data/lib/tasks/exwiw.rake

@@ -11,6 +11,26 @@ namespace :exwiw do
       ).generate!
     end
 
+    desc "Remove tables/columns from the schema config that no longer exist in the application"
+    task tidy: :environment do
+      require "exwiw"
+
+      result = Exwiw::SchemaGenerator.from_rails_application(
+        output_dir: ENV["OUTPUT_DIR_PATH"] || "exwiw",
+      ).tidy!
+
+      if result.empty?
+        puts "exwiw: schema config is already tidy; nothing to remove."
+      else
+        result.removed_tables.each do |name|
+          puts "exwiw: removed config for table '#{name}' (no longer exists in the application)."
+        end
+        result.removed_columns.each do |table_name, columns|
+          puts "exwiw: removed column(s) #{columns.join(', ')} from '#{table_name}' (no longer in the table)."
+        end
+      end
+    end
+
     desc "Generate schema from a Mongoid application"
     task generate_mongoid: :environment do
       require "exwiw"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exwiw
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
 platform: ruby
 authors:
 - Shia