migsupo 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f22d99bd89a407d32621aadf871aa3a6059291b338aa2df6b9f12cd29fa6abf
-  data.tar.gz: 555ccc440d31b410b015f4975b3835f590fa15e900c759d166b3ad1cbb842327
+  metadata.gz: 46769b47cf0ccd1fddb7f3391c43cdec1cbe20df56cb3d18efdafc22c9427c09
+  data.tar.gz: a8edc433d3472182ddcfd5be264704c6d21ad58d70e491934c3f92cbf53cd3ed
 SHA512:
-  metadata.gz: c9d49e0b2092d947a31783bad5c5052b658da6be8b383f4473e91d0afa82e59a0f198288fcffd9eeb03b3a787b85771cefa2bac502fd806616d8460bd5419362
-  data.tar.gz: cb2ff4341a47c1c646b32cce37dc771b1e85acb1d42d97b42394f8d15f174716707495d118731d8043a8d468eb8fd17414f041ceff7001b23fc4b0539c5c89cb
+  metadata.gz: 03a340761dfb39ff21b8d80d98f1901b2e553c6b57b8178e0927fdb78db6f0247034c98d2e159379b754700d8ecd7e46ac45d24966794344a920dd93d1a49aae
+  data.tar.gz: cbeba7b4ec1da9528edec1ef4efd7c52d25101d3e6f8f071f4bddde68d23a30a059740b902a99475b620cea0f39aa12aa17a67bdc752fd6813045c6262b6b9cf

data/README.md

@@ -122,6 +122,113 @@ Exit with code 1 if the Schemafile and the current database are not in sync. Use
 rails db:generate_migration:check
 ```
 
+### `rails db:coherent` / `rails db:coherent:apply`
+
+Adopt a hand-made database change as the truth. See [coherent](#coherent--when-the-db-was-changed-by-hand).
+
+### `rails db:squash` / `rails db:squash:apply`
+
+Collapse the whole migration history into a single `Init` migration. See [squash](#squash--collapse-the-history-into-one-init-migration).
+
+## `coherent` — when the DB was changed by hand
+
+Sometimes someone edits the database directly — an emergency `ALTER TABLE` in production, say — and that state is the one you want to keep. The normal flow cannot express this: the Schemafile is behind, and running a migration to catch up would touch columns that are already correct.
+
+`coherent` takes the **DB as the source of truth** and moves everything else up to it: it writes the migration file that *would* have produced the change (so every other environment gets it through the normal `rails db:migrate`), updates the Schemafile, and then records the migration as applied on this database **without executing it**.
+
+```
+DB (hand-edited, = truth)
+  ├─ db:coherent        → db/migrate/*.rb (generated) + Schemafile (updated)
+  └─ db:coherent:apply  → INSERT INTO schema_migrations   ← columns untouched
+                          db/schema.rb re-dumped
+```
+
+### 1. Generate
+
+```bash
+rails db:coherent
+```
+
+```
+Adopting the following from the database:
+add_column users.nickname (string)
+
+Generated migration(s):
+  db/migrate/20260901120000_add_columns_to_users.rb
+Updated Schemafile: Schemafile
+
+Review them, then record the history without touching the database:
+  rails db:coherent:apply VERSION=20260901120000
+```
+
+The diff runs in the opposite direction from `db:generate_migration`: the DB is the desired state and the Schemafile is the current one, so a column that exists only in the DB comes out as `add_column`, not `remove_column`.
+
+### 2. Review, then rewrite history only
+
+```bash
+rails db:coherent:apply VERSION=20260901120000
+```
+
+This inserts the version into `schema_migrations` and re-dumps `db/schema.rb`. No DDL is executed — the columns are already where they should be.
+
+`VERSION` is required (comma-separate several). Run without it to list the pending migrations. Before writing anything, `apply` re-checks that the DB and the Schemafile match: if they do not, the migration genuinely needs to run and the task aborts.
+
+### On other environments
+
+Nothing special. `db/migrate/*.rb` is a normal migration, so staging and production pick it up with `rails db:migrate`.
+
+### Caveats
+
+- `db:coherent` regenerates the whole Schemafile from the DB, so hand-written comments and ordering in it are lost. Review the diff (`git diff Schemafile`) before committing.
+- `rename_hints` are not applied — a column renamed by hand comes out as `remove_column` + `add_column`.
+- Only what migsupo models is tracked: tables, columns, indexes. Foreign keys, extensions and check constraints are neither diffed nor written to the Schemafile.
+- Primary key options (`id: :uuid`, `primary_key: "uid"`) are not read back from the database, so the regenerated Schemafile drops them. Diffs are unaffected — table options are not compared — but re-add them by hand if you ever recreate the table from the Schemafile.
+
+## `squash` — collapse the history into one Init migration
+
+When `db/migrate` has grown long, `squash` replaces every migration file with a single `<timestamp>_init.rb` that creates the whole schema as declared in the Schemafile, and then rewrites `schema_migrations` to hold only that version. No DDL is executed.
+
+```
+db/migrate/*.rb (N files)
+  ├─ db:squash        → db/migrate/<ts>_init.rb   (all other files deleted)
+  └─ db:squash:apply  → schema_migrations = [<ts>]   ← tables untouched
+                        db/schema.rb re-dumped
+```
+
+### 1. Generate
+
+```bash
+rails db:squash
+rails db:squash DRY_RUN=true   # print the Init migration, change nothing
+```
+
+It aborts unless both hold:
+
+- every migration file has been applied (pending ones may carry data migrations the Schemafile cannot express)
+- the DB matches the Schemafile (the Init migration must reproduce this exact DB)
+
+### 2. Review, then rewrite history
+
+```bash
+rails db:squash:apply VERSION=20261103120000
+```
+
+`VERSION` can be omitted when `db/migrate` holds exactly one file (right after `db:squash`); that one is used.
+
+### On other environments
+
+Unlike `coherent`, this is **not** picked up by plain `rails db:migrate` — the Init migration would try to create tables that already exist. On every existing environment:
+
+1. Deploy the pre-squash code and run `rails db:migrate` so the DB matches the Schemafile.
+2. Deploy the squashed code and run `rails db:squash:apply VERSION=<ts>` **before** `rails db:migrate`.
+
+New environments just run `rails db:migrate` (or `db:schema:load`).
+
+### Caveats
+
+- Data migrations and raw SQL in the old files are gone. Keep them elsewhere if you still need them.
+- Only what migsupo models is emitted: tables, columns, indexes. Foreign keys, extensions and check constraints are not in the Init migration.
+
 ## Environment Variables
 
 | Variable | Default | Description |

data/lib/migsupo/coherent.rb

@@ -0,0 +1,71 @@
+require_relative "parser/schemafile_parser"
+require_relative "loader/active_record_loader"
+require_relative "differ/diff_calculator"
+require_relative "generator/schemafile_dumper"
+
+module Migsupo
+  # For the case where the DB was changed by hand and that state is now the
+  # truth. Coherent brings the Schemafile and the migration history up to the
+  # DB without touching a single column.
+  module Coherent
+    module_function
+
+    # desired/current are swapped on purpose: the migration has to move the
+    # declared state up to what the DB already looks like.
+    # ponytail: rename_hints point the other way here, so they are dropped -
+    # a hand-renamed column comes out as remove + add.
+    def diff(schemafile_path: nil)
+      schemafile_path ||= Migsupo.configuration.schemafile_path
+      declared = Parser::SchemafileParser.parse(schemafile_path)
+
+      Differ::DiffCalculator.new.calculate(desired: actual_schema, current: declared)
+    end
+
+    def dump_schemafile(path: nil)
+      path ||= Migsupo.configuration.schemafile_path
+      File.write(path, Generator::SchemafileDumper.new.dump(actual_schema))
+      path
+    end
+
+    # Writes history only - no DDL is executed. Returns the versions inserted.
+    def mark_applied(versions)
+      applied = applied_versions
+      inserted = versions.map(&:to_s) - applied
+
+      table = connection.quote_table_name("schema_migrations")
+      inserted.each do |version|
+        connection.execute("INSERT INTO #{table} (version) VALUES (#{connection.quote(version)})")
+      end
+      inserted
+    end
+
+    def applied_versions
+      connection.select_values(
+        "SELECT version FROM #{connection.quote_table_name('schema_migrations')}"
+      ).map(&:to_s)
+    end
+
+    # [version, filename] for every migration file not yet in schema_migrations.
+    def pending(migrations_dir = nil)
+      migrations_dir ||= Migsupo.configuration.migrations_dir
+      applied = applied_versions
+
+      migration_files(migrations_dir).reject { |version, _| applied.include?(version) }
+    end
+
+    def migration_files(migrations_dir)
+      Dir.glob(File.join(migrations_dir, "*.rb")).sort.filter_map do |path|
+        version = File.basename(path)[/\A\d+/]
+        [version, File.basename(path)] if version
+      end
+    end
+
+    def actual_schema
+      Loader::ActiveRecordLoader.new(ignored_tables: Migsupo.configuration.ignored_tables).load_schema
+    end
+
+    def connection
+      ActiveRecord::Base.connection
+    end
+  end
+end

data/lib/migsupo/generator/migration_builder.rb

@@ -32,6 +32,12 @@ module Migsupo
         RUBY
       end
 
+      # Renders one create_table block (plus its add_index lines) - the same shape
+      # a Schemafile uses.
+      def build_table(table)
+        render_create_table(Differ::Operations::CreateTable.new(table))
+      end
+
       private
 
       def version_suffix
@@ -102,7 +108,7 @@ module Migsupo
 
       def render_drop_table(op, direction:)
         if direction == :down
-          render_create_table(Operations::CreateTable.new(op.table))
+          render_create_table(Differ::Operations::CreateTable.new(op.table))
         else
           "drop_table #{op.table_name.inspect}"
         end

data/lib/migsupo/generator/schemafile_dumper.rb

@@ -0,0 +1,18 @@
+require_relative "migration_builder"
+
+module Migsupo
+  module Generator
+    # Renders a SchemaDefinition back out as Schemafile DSL.
+    # Only what migsupo models (tables / columns / indexes) is emitted, so the
+    # output always round-trips through SchemafileParser.
+    class SchemafileDumper
+      def initialize
+        @builder = MigrationBuilder.new
+      end
+
+      def dump(schema)
+        "#{schema.tables.values.map { |table| @builder.build_table(table) }.join("\n\n")}\n"
+      end
+    end
+  end
+end

data/lib/migsupo/squash.rb

@@ -0,0 +1,44 @@
+require_relative "parser/schemafile_parser"
+require_relative "generator/migration_builder"
+require_relative "differ/operations/create_table"
+require_relative "coherent"
+
+module Migsupo
+  # Collapses the whole migration history into a single Init migration built
+  # from the Schemafile, then rewrites schema_migrations to match - no DDL.
+  module Squash
+    module_function
+
+    # Built from the Schemafile, not the DB: the DB loader drops primary key
+    # options (id: :uuid etc.), the Schemafile keeps them.
+    def build(schemafile_path: nil, rails_version: nil)
+      schemafile_path ||= Migsupo.configuration.schemafile_path
+      schema = Parser::SchemafileParser.parse(schemafile_path)
+      ops    = schema.tables.values.map { |table| Differ::Operations::CreateTable.new(table) }
+
+      Generator::MigrationBuilder.new(rails_version: rails_version).build(ops, class_name: "Init")
+    end
+
+    # Deletes every migration file and writes <timestamp>_init.rb. Returns its path.
+    def write(content, migrations_dir: nil)
+      migrations_dir ||= Migsupo.configuration.migrations_dir
+      Dir.glob(File.join(migrations_dir, "*.rb")).each { |path| File.delete(path) }
+
+      path = File.join(migrations_dir, "#{Time.now.strftime('%Y%m%d%H%M%S')}_init.rb")
+      File.write(path, content)
+      path
+    end
+
+    # Replaces all history with the single version. Atomic so a failure
+    # cannot leave schema_migrations empty.
+    def rewrite_history(version)
+      connection = Coherent.connection
+      table = connection.quote_table_name("schema_migrations")
+
+      connection.transaction do
+        connection.execute("DELETE FROM #{table}")
+        connection.execute("INSERT INTO #{table} (version) VALUES (#{connection.quote(version.to_s)})")
+      end
+    end
+  end
+end

data/lib/migsupo/tasks/migsupo.rake

@@ -54,3 +54,160 @@ namespace :db do
     end
   end
 end
+
+namespace :db do
+  desc "Take the current DB as truth: generate migrations for hand-made changes and update the Schemafile"
+  task coherent: :environment do
+    schemafile_path = ENV.fetch("SCHEMAFILE", Migsupo.configuration.schemafile_path)
+    output_dir      = ENV.fetch("OUTPUT_DIR", Migsupo.configuration.migrations_dir)
+    dry_run         = ENV["DRY_RUN"] == "true"
+
+    diff = Migsupo::Coherent.diff(schemafile_path: schemafile_path)
+
+    if diff.empty?
+      puts "No differences between the database and the Schemafile. Nothing for coherent to do."
+      next
+    end
+
+    puts "Adopting the following from the database:"
+    puts diff.to_s
+    puts
+
+    files = Migsupo.generate_migrations(diff, output_dir: output_dir, dry_run: dry_run)
+    next if dry_run
+
+    Migsupo::Coherent.dump_schemafile(path: schemafile_path)
+    versions = files.map { |f| File.basename(f)[/\A\d+/] }
+
+    puts "Generated migration(s):"
+    files.each { |f| puts "  #{f}" }
+    puts "Updated Schemafile: #{schemafile_path}"
+    puts
+    puts "Review them, then record the history without touching the database:"
+    puts "  rails db:coherent:apply VERSION=#{versions.join(',')}"
+  end
+
+  namespace :coherent do
+    desc "Mark the given migrations as applied without running them (VERSION=ts[,ts...])"
+    task apply: :environment do
+      schemafile_path = ENV.fetch("SCHEMAFILE", Migsupo.configuration.schemafile_path)
+      output_dir      = ENV.fetch("OUTPUT_DIR", Migsupo.configuration.migrations_dir)
+      versions        = ENV["VERSION"].to_s.split(",").map(&:strip).reject(&:empty?)
+
+      if versions.empty?
+        puts "VERSION is required (e.g. VERSION=20260901120000)."
+        pending = Migsupo::Coherent.pending(output_dir)
+        if pending.empty?
+          puts "No pending migrations."
+        else
+          puts "Pending migrations:"
+          pending.each { |version, name| puts "  #{version}  #{name}" }
+        end
+        exit 1
+      end
+
+      known = Migsupo::Coherent.migration_files(output_dir).to_h
+      unknown = versions.reject { |v| known.key?(v) }
+      unless unknown.empty?
+        puts "No migration found in #{output_dir} for: #{unknown.join(', ')}"
+        exit 1
+      end
+
+      # Recording history only is sound when the DB already matches the
+      # Schemafile. A remaining diff means the migration genuinely needs to run.
+      diff = Migsupo::Coherent.diff(schemafile_path: schemafile_path)
+      unless diff.empty?
+        puts "The database and the Schemafile do not match. Run rails db:coherent first:"
+        puts diff.to_s
+        exit 1
+      end
+
+      inserted = Migsupo::Coherent.mark_applied(versions)
+      skipped  = versions - inserted
+
+      inserted.each { |v| puts "Recorded as applied: #{v}  #{known[v]}" }
+      skipped.each  { |v| puts "Already recorded, skipped: #{v}  #{known[v]}" }
+
+      Rake::Task["db:schema:dump"].invoke
+      puts "Updated db/schema.rb."
+    end
+  end
+end
+
+namespace :db do
+  desc "Collapse every migration into a single Init migration built from the Schemafile"
+  task squash: :environment do
+    schemafile_path = ENV.fetch("SCHEMAFILE", Migsupo.configuration.schemafile_path)
+    output_dir      = ENV.fetch("OUTPUT_DIR", Migsupo.configuration.migrations_dir)
+    dry_run         = ENV["DRY_RUN"] == "true"
+
+    # Pending files may hold data migrations that the Schemafile cannot express.
+    pending = Migsupo::Coherent.pending(output_dir)
+    unless pending.empty?
+      puts "Run the pending migrations before squashing:"
+      pending.each { |version, name| puts "  #{version}  #{name}" }
+      exit 1
+    end
+
+    # Init replaces the history only if it reproduces this exact DB.
+    diff = Migsupo.calculate_diff(schemafile_path: schemafile_path, loader: :active_record)
+    unless diff.empty?
+      puts "The database and the Schemafile do not match. Bring them in sync before squashing:"
+      puts diff.to_s
+      exit 1
+    end
+
+    content = Migsupo::Squash.build(schemafile_path: schemafile_path, rails_version: Migsupo.detect_rails_version)
+    if dry_run
+      puts content
+      next
+    end
+
+    removed = Migsupo::Coherent.migration_files(output_dir).size
+    path    = Migsupo::Squash.write(content, migrations_dir: output_dir)
+    version = File.basename(path)[/\A\d+/]
+
+    puts "Removed #{removed} migration file(s) and generated:"
+    puts "  #{path}"
+    puts
+    puts "Review it, then replace the history on every environment (no DDL is executed):"
+    puts "  rails db:squash:apply VERSION=#{version}"
+  end
+
+  namespace :squash do
+    desc "Replace schema_migrations with the single Init version (VERSION=ts)"
+    task apply: :environment do
+      schemafile_path = ENV.fetch("SCHEMAFILE", Migsupo.configuration.schemafile_path)
+      output_dir      = ENV.fetch("OUTPUT_DIR", Migsupo.configuration.migrations_dir)
+      version         = ENV["VERSION"].to_s.strip
+
+      if version.empty?
+        files = Migsupo::Coherent.migration_files(output_dir)
+        unless files.size == 1
+          puts "VERSION is required when #{output_dir} does not hold exactly one migration (found #{files.size})."
+          exit 1
+        end
+        version = files.first.first
+        puts "Using #{files.first.last}"
+      end
+
+      unless Migsupo::Coherent.migration_files(output_dir).to_h[version]
+        puts "No migration found in #{output_dir} for: #{version}"
+        exit 1
+      end
+
+      diff = Migsupo.calculate_diff(schemafile_path: schemafile_path, loader: :active_record)
+      unless diff.empty?
+        puts "The database and the Schemafile do not match. Run rails db:migrate on the pre-squash code first:"
+        puts diff.to_s
+        exit 1
+      end
+
+      Migsupo::Squash.rewrite_history(version)
+      puts "schema_migrations now holds only: #{version}"
+
+      Rake::Task["db:schema:dump"].invoke
+      puts "Updated db/schema.rb."
+    end
+  end
+end

data/lib/migsupo/version.rb

@@ -1,3 +1,3 @@
 module Migsupo
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/migsupo.rb

@@ -9,6 +9,8 @@ require_relative "migsupo/loader/active_record_loader"
 require_relative "migsupo/loader/schema_rb_loader"
 require_relative "migsupo/differ/diff_calculator"
 require_relative "migsupo/generator/migration_generator"
+require_relative "migsupo/coherent"
+require_relative "migsupo/squash"
 
 module Migsupo
   class << self
@@ -38,6 +40,14 @@ module Migsupo
                                    .generate(diff, output_dir: output_dir, dry_run: dry_run)
     end
 
+    def detect_rails_version
+      return configuration.migration_version if configuration.migration_version
+      return nil unless defined?(Rails)
+
+      major_minor = Rails::VERSION::STRING.split(".").first(2).join(".")
+      major_minor
+    end
+
     private
 
     def build_loader(loader)
@@ -61,14 +71,6 @@ module Migsupo
         "db/schema.rb"
       end
     end
-
-    def detect_rails_version
-      return configuration.migration_version if configuration.migration_version
-      return nil unless defined?(Rails)
-
-      major_minor = Rails::VERSION::STRING.split(".").first(2).join(".")
-      major_minor
-    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: migsupo
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - masak1yu
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-24 00:00:00.000000000 Z
+date: 1980-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -103,6 +103,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/migsupo.rb
+- lib/migsupo/coherent.rb
 - lib/migsupo/configuration.rb
 - lib/migsupo/differ/diff.rb
 - lib/migsupo/differ/diff_calculator.rb
@@ -117,6 +118,7 @@ files:
 - lib/migsupo/generator/migration_builder.rb
 - lib/migsupo/generator/migration_generator.rb
 - lib/migsupo/generator/naming.rb
+- lib/migsupo/generator/schemafile_dumper.rb
 - lib/migsupo/loader/active_record_loader.rb
 - lib/migsupo/loader/schema_rb_loader.rb
 - lib/migsupo/parser/dsl_context.rb
@@ -127,6 +129,7 @@ files:
 - lib/migsupo/schema/index_definition.rb
 - lib/migsupo/schema/schema_definition.rb
 - lib/migsupo/schema/table_definition.rb
+- lib/migsupo/squash.rb
 - lib/migsupo/tasks/migsupo.rake
 - lib/migsupo/version.rb
 - migsupo.gemspec
@@ -149,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Generate Rails migrations from a Schemafile diff