exwiw 0.3.7 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91f070d56a04f45680e1c858109fd6828d69220373ad725d07c248d4c8ed2f10
-  data.tar.gz: a2dc34318e0c0a15ec8af84d75330b92ce5278c14a5b88d6e824e26bc5b1f6a7
+  metadata.gz: ea6a0b4fda446d66766027139136320937a59319bfe28d83ee595cf062a4023a
+  data.tar.gz: 1ce3d4a7601ae6b3f1fe6ca8ed22e977389ac7ab46973c33113206911893326e
 SHA512:
-  metadata.gz: 5700d2fd7287c365ef6c9759fd7f5e85188db6e568b32f8c29a4a0f9f3479d967014a1f77bbf64e1d0e20fdfd75004d05e86e5152d781d6fcae8a5cbf82bca1b
-  data.tar.gz: '09d1f99b70a0f7d0a8e12fbb0f69de776b9932db9fdc386b71fb3822ee118eda786be79737e3a2e85c340d8c6ce15e5bca472e61d4f4f6517f0bc34d133db9d1'
+  metadata.gz: '08ffcb1713110629652b4047b159613ab3d13e5fffcd092433282f28564328d1609572d8f159b1c0e7fddfab1be4fc92651b8f819ddfa44a913e18da04e4aeef'
+  data.tar.gz: 77529a1897ded0943898f60d8a55d54bfdf35f80fc512b57be7300adad9fc8c99767199de8e6d9fb9649dc2644fbcfc2252e445de2f5c38bc20aece5ae4a56d5

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [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
+
+- ActiveStorage support is now complete. `schema:generate` follows `has_one_attached` / `has_many_attached` macros so `active_storage_attachments` is extracted correctly via its polymorphic `belongs_to`. `active_storage_blobs` is no longer dumped wholesale: a reverse "referenced_by" extraction (a `SELECT` subquery) narrows it to only the blobs referenced by the extracted attachments. `active_storage_variant_records` (derivative, regenerable variant-tracking rows) is now emitted with `ignore: true` instead of being dumped in full — it has no path to a dump target and its `blob_id` could otherwise reference blobs outside the narrowed set, causing a foreign-key violation on import. It is also dropped from the attachments `record` polymorphic expansion so the non-ignored attachments table carries no dangling belongs_to to it. ([#69](https://github.com/heyinc/exwiw/pull/69))
+
 ## [0.3.7] - 2026-06-01
 
 - bug fix https://github.com/heyinc/exwiw/pull/67

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`, ...):
@@ -341,6 +358,25 @@ WHERE reviews.reviewable_id IN (/* products subquery */)
 
 The same type filter is applied on the join path — and in the matching `delete-*.sql` bulk-delete subquery — when the polymorphic table is an intermediate hop rather than the directly-dumped table.
 
+### ActiveStorage (`has_one_attached` / `has_many_attached`)
+
+ActiveStorage is handled automatically — no ActiveStorage-specific configuration is required. The `has_one_attached` / `has_many_attached` macros don't add a column to the owning model; they generate ordinary associations that exwiw already understands:
+
+- **`active_storage_attachments`** is the polymorphic join row (`belongs_to :record, polymorphic: true` + `belongs_to :blob`). `exwiw:schema:generate` expands the polymorphic `record` into one `belongs_to` per model that declared `has_*_attached` (found via the generated `has_* ..., as: :record` reflections), exactly like any other [polymorphic `belongs_to`](#polymorphic-belongs_to). So only the attachments whose owner is among the dumped rows are extracted.
+- **`active_storage_blobs`** has no `belongs_to` of its own (attachments point *at* it), so it has no path to the dump target. exwiw narrows it via **reverse / "referenced_by" extraction**: a parent table referenced by exactly one constrained, non-polymorphic child is constrained to just the referenced ids instead of dumping every row:
+
+  ```sql
+  SELECT active_storage_blobs.* FROM active_storage_blobs
+  WHERE active_storage_blobs.id IN (
+    SELECT active_storage_attachments.blob_id FROM active_storage_attachments
+    WHERE active_storage_attachments.record_id IN (/* owner subquery */)
+      AND active_storage_attachments.record_type = '...'
+  )
+  ```
+
+  `active_storage_variant_records` also references blobs, but since it has no path of its own to the dump target it doesn't constrain anything and is ignored as a referencer — blobs stays narrowed to the attachment-referenced ids. (A parent referenced by *multiple* constrained children currently falls back to dumping all of its rows.)
+- **`active_storage_variant_records`** holds derivative variant-tracking rows that ActiveStorage regenerates lazily, and it too has no path to the dump target — left alone it would land in the "no relation → dump all" branch and, worse, its `blob_id` could point at blobs outside the narrowed set above (a foreign-key violation on import). `exwiw:schema:generate` therefore emits it with **`ignore: true`** (and drops it from the attachments `record` polymorphic expansion so nothing carries a dangling reference to it), so its data is skipped while the DDL is still written. Remove `ignore` from the generated config if you really need to export it.
+
 ### Rails-managed tables (special `type` values)
 
 Some tables are owned by Rails itself rather than the application — they have no ActiveRecord model and Rails reserves the right to evolve their column shape between versions (e.g. `schema_migrations`, `ar_internal_metadata`). exwiw treats them as a distinct category via the `type` field on a table config:

data/lib/exwiw/adapter/mysql_adapter.rb

@@ -226,6 +226,10 @@ module Exwiw
       end
 
       private def compile_subquery(subquery)
+        # A SelectSubquery wraps a full Select (the referencing table's
+        # extraction query, projected to a foreign key); compile it as-is.
+        return compile_ast(subquery.query) if subquery.is_a?(Exwiw::QueryAst::SelectSubquery)
+
         inner_values = subquery.where_values.map { |v| escape_value(v) }
         "SELECT #{subquery.table_name}.#{subquery.select_column} " \
           "FROM #{subquery.table_name} " \

data/lib/exwiw/adapter/postgresql_adapter.rb

@@ -253,6 +253,10 @@ module Exwiw
       end
 
       private def compile_subquery(subquery)
+        # A SelectSubquery wraps a full Select (the referencing table's
+        # extraction query, projected to a foreign key); compile it as-is.
+        return compile_ast(subquery.query) if subquery.is_a?(Exwiw::QueryAst::SelectSubquery)
+
         inner_values = subquery.where_values.map { |v| escape_value(v) }
         "SELECT #{subquery.table_name}.#{subquery.select_column} " \
           "FROM #{subquery.table_name} " \

data/lib/exwiw/adapter/sqlite_adapter.rb

@@ -198,6 +198,10 @@ module Exwiw
       end
 
       private def compile_subquery(subquery)
+        # A SelectSubquery wraps a full Select (the referencing table's
+        # extraction query, projected to a foreign key); compile it as-is.
+        return compile_ast(subquery.query) if subquery.is_a?(Exwiw::QueryAst::SelectSubquery)
+
         inner_values = subquery.where_values.map { |v| escape_value(v) }
         "SELECT #{subquery.table_name}.#{subquery.select_column} " \
           "FROM #{subquery.table_name} " \

data/lib/exwiw/query_ast.rb

@@ -41,7 +41,7 @@ module Exwiw
         {
           column_name: column_name,
           operator: operator,
-          value: value.is_a?(Subquery) ? value.to_h : value,
+          value: value.is_a?(Subquery) || value.is_a?(SelectSubquery) ? value.to_h : value,
         }
       end
     end
@@ -65,6 +65,24 @@ module Exwiw
       end
     end
 
+    # A subquery whose body is a full `Select`, projected down to a single
+    # column. Unlike the flat `Subquery` above (one column = one IN-list), this
+    # carries the referencing table's complete extraction query — joins,
+    # multiple where conditions, polymorphic type filters and all. Used by the
+    # reverse / "referenced_by" extraction so a parent table with no belongs_to
+    # path to the dump target (e.g. active_storage_blobs) is constrained to only
+    # the rows referenced by an extractable child table:
+    #
+    #   <parent>.<pk> IN (SELECT <child>.<fk> FROM <child> WHERE <child filters>)
+    #
+    # `query` is the child's `Select` already projected to the foreign-key
+    # column that points at the parent.
+    SelectSubquery = Struct.new(:query, keyword_init: true) do
+      def to_h
+        { query: query.to_h }
+      end
+    end
+
     module ColumnValue
       Base = Struct.new(:name, :value, keyword_init: true)
       Plain = Class.new(Base)
@@ -103,6 +121,15 @@ module Exwiw
         @join_clauses << join_clause
       end
 
+      def to_h
+        {
+          from: from_table_name,
+          columns: select_all ? "*" : columns.map { |c| { name: c.name, value: c.value } },
+          joins: join_clauses.map(&:to_h),
+          where: where_clauses.map { |w| w.is_a?(String) ? w : w.to_h },
+        }
+      end
+
       private def map_column_value(columns)
         columns.map do |c|
           if c.raw_sql

data/lib/exwiw/query_ast_builder.rb

@@ -2,17 +2,18 @@
 
 module Exwiw
   class QueryAstBuilder
-    def self.run(table_name, table_by_name, dump_target, logger)
-      new(table_name, table_by_name, dump_target, logger).run
+    def self.run(table_name, table_by_name, dump_target, logger, allow_reverse: true)
+      new(table_name, table_by_name, dump_target, logger, allow_reverse: allow_reverse).run
     end
 
     attr_reader :table_name, :table_by_name, :dump_target
 
-    def initialize(table_name, table_by_name, dump_target, logger)
+    def initialize(table_name, table_by_name, dump_target, logger, allow_reverse: true)
       @table_name = table_name
       @table_by_name = table_by_name
       @dump_target = dump_target
       @logger = logger
+      @allow_reverse = allow_reverse
     end
 
     def run
@@ -21,6 +22,19 @@ module Exwiw
       where_clauses = build_where_clauses(table, dump_target)
       join_clauses = build_join_clauses(table, table_by_name, dump_target)
 
+      # Reverse / "referenced_by" extraction. A table with no belongs_to path to
+      # the dump target produces no where/join clauses and would otherwise dump
+      # every row (see the "no relation -> dump all" case). If an extractable
+      # child table references it via a foreign key (e.g. active_storage_blobs is
+      # referenced by active_storage_attachments.blob_id), constrain it to just
+      # the referenced ids instead. Disabled (@allow_reverse=false) while building
+      # a child's subquery, so this never recurses.
+      if @allow_reverse && table.name != dump_target.table_name &&
+         where_clauses.empty? && join_clauses.empty?
+        reverse_clause = build_referenced_by_clause(table)
+        where_clauses.push(reverse_clause) if reverse_clause
+      end
+
       QueryAst::Select.new.tap do |ast|
         ast.from(table.name)
         if table.rails_managed?
@@ -100,6 +114,61 @@ module Exwiw
       join_clauses
     end
 
+    # Builds a `pk IN (SELECT child.fk FROM <child extraction query>)` clause
+    # for a table that is referenced by an extractable child table but has no
+    # belongs_to of its own toward the dump target. Returns nil when there is no
+    # such (single, unambiguous) referencer, leaving the caller to fall back to
+    # the dump-all behavior.
+    private def build_referenced_by_clause(table)
+      candidates = table_by_name.each_value.filter_map do |other|
+        next if other.name == table.name
+
+        relation = other.belongs_to(table.name)
+        # A polymorphic foreign key stores ids of several models in one column,
+        # so projecting it would pull in unrelated parents. Skip it here; the
+        # non-polymorphic blob_id on active_storage_attachments is what we want.
+        next if relation.nil? || relation.polymorphic?
+
+        # Build the child's own extraction query. allow_reverse:false stops a
+        # chain of FK-less tables from recursing back into each other.
+        child_query = self.class.run(other.name, table_by_name, dump_target, @logger, allow_reverse: false)
+
+        # Only an *already constrained* child narrows anything; an unconstrained
+        # child would select every fk value (i.e. dump all) and not help.
+        next unless child_query.where_clauses.any? || child_query.join_clauses.any?
+
+        [relation, child_query]
+      end
+
+      # Scope: only the unambiguous single-referencer case. Multiple referencers
+      # would need their subqueries OR'd together (not yet supported); falling
+      # back to dump-all preserves today's behavior for those.
+      if candidates.size != 1
+        if candidates.size > 1
+          @logger.debug("  #{table.name} has multiple referencing tables; skipping reverse extraction (dump all).")
+        end
+        return nil
+      end
+
+      relation, child_query = candidates.first
+
+      # Project the child's extraction query down to just the foreign key that
+      # points at `table`. Force a plain column so any masking/raw_sql configured
+      # on that column does not corrupt the id comparison.
+      fk_column = TableColumn.from_symbol_keys(name: relation.foreign_key)
+      projected = QueryAst::Select.new
+      projected.from(child_query.from_table_name)
+      projected.select([fk_column])
+      child_query.join_clauses.each { |j| projected.join(j) }
+      child_query.where_clauses.each { |w| projected.where(w) }
+
+      QueryAst::WhereClause.new(
+        column_name: table.primary_key,
+        operator: :in_subquery,
+        value: QueryAst::SelectSubquery.new(query: projected)
+      )
+    end
+
     private def build_where_clauses(table, dump_target)
       clauses = []
 

data/lib/exwiw/schema_generator.rb

@@ -5,6 +5,44 @@ 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
+    # importantly, the table has no belongs_to path to any dump target, which
+    # would land it in QueryAstBuilder's "no relation -> dump all" branch, while
+    # its `blob_id` references active_storage_blobs, which the reverse
+    # "referenced_by" extraction narrows to only the attachment-referenced blobs.
+    # A full variant_records dump can therefore reference blobs that were never
+    # exported (a foreign-key violation on import). So the table is emitted with
+    # `ignore: true` (data extraction skipped) and excluded as a polymorphic
+    # `record` target so the non-ignored attachments table carries no dangling
+    # belongs_to to it.
+    ACTIVE_STORAGE_VARIANT_RECORDS_TABLE = "active_storage_variant_records"
+
     def self.from_rails_application(output_dir:)
       Rails.application.eager_load!
       new(models: ActiveRecord::Base.descendants, output_dir: output_dir)
@@ -21,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
@@ -30,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
@@ -53,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)
 
@@ -94,6 +210,20 @@ module Exwiw
             belongs_tos: aggregate_belongs_tos(model_group),
             columns: representative.column_names.map { |name| { name: name } },
           )
+        elsif table_name == ACTIVE_STORAGE_VARIANT_RECORDS_TABLE
+          # See ACTIVE_STORAGE_VARIANT_RECORDS_TABLE. Emitted with ignore:true so
+          # the derivative variant rows are not dumped; primary_key/columns are
+          # kept so a user can remove `ignore` to opt back in if they really want
+          # to export them.
+          TableConfig.from_symbol_keys(
+            name: table_name,
+            primary_key: primary_key,
+            ignore: true,
+            comment: "ActiveStorage variant tracking records are derivative and " \
+                     "regenerable; data extraction is skipped. Remove `ignore` to export them.",
+            belongs_tos: aggregate_belongs_tos(model_group),
+            columns: representative.column_names.map { |name| { name: name } },
+          )
         else
           TableConfig.from_symbol_keys(
             name: table_name,
@@ -203,6 +333,12 @@ module Exwiw
     # belongs_to ordering stable.
     private def polymorphic_target_models(association_name)
       concrete_models.select do |model|
+        # active_storage_variant_records is ignored (see the constant), so it must
+        # not be expanded as a polymorphic target — otherwise the non-ignored
+        # attachments table would carry a dangling belongs_to to an ignored table,
+        # which is rejected at load time.
+        next false if model.table_name == ACTIVE_STORAGE_VARIANT_RECORDS_TABLE
+
         (model.reflect_on_all_associations(:has_many) +
          model.reflect_on_all_associations(:has_one))
           .any? { |reflection| reflection.options[:as] == association_name }

data/lib/exwiw/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Exwiw
-  VERSION = "0.3.7"
+  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.7
+  version: 0.3.9
 platform: ruby
 authors:
 - Shia