migsupo 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f22d99bd89a407d32621aadf871aa3a6059291b338aa2df6b9f12cd29fa6abf
-  data.tar.gz: 555ccc440d31b410b015f4975b3835f590fa15e900c759d166b3ad1cbb842327
+  metadata.gz: f6bd6bc4627dd5769bb11ae7f872a7234a09eccf52b4ed9661e162d7049dc87a
+  data.tar.gz: 796a9c73842e770248796ce1f35a5def6e006fe9c44b31485fd9ca21f98ac31f
 SHA512:
-  metadata.gz: c9d49e0b2092d947a31783bad5c5052b658da6be8b383f4473e91d0afa82e59a0f198288fcffd9eeb03b3a787b85771cefa2bac502fd806616d8460bd5419362
-  data.tar.gz: cb2ff4341a47c1c646b32cce37dc771b1e85acb1d42d97b42394f8d15f174716707495d118731d8043a8d468eb8fd17414f041ceff7001b23fc4b0539c5c89cb
+  metadata.gz: 88c10374ed224574113524e17ea4856f8671f04022a669899136691c87387580f57f49d91458887261a962d143d033875a633b8e829ccff4fdaa9e8e338ed9a5
+  data.tar.gz: 14719373ed30592817a1b0e9107dd613fb3936c1c47a977fd0e38d8067bcf0ef982b2bae5df1cac74308a7bcecfa480559fa069b988ea3d32f378f7d641d3250

data/README.md

@@ -122,6 +122,64 @@ 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).
+
+## `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.
+
 ## 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/tasks/migsupo.rake

@@ -54,3 +54,82 @@ 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

data/lib/migsupo/version.rb

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

data/lib/migsupo.rb

@@ -9,6 +9,7 @@ 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"
 
 module Migsupo
   class << self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: migsupo
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.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
@@ -149,7 +151,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