actual_db_schema 0.7.9 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a0d117f27b4bd908cbc04b0d3ca0faf0297a5feed5fd4f869c5672a50fc3cd9
-  data.tar.gz: cf0f37bc743eb44c8c5f6350454cc7f84f1781c8a8bc06ef25eb878830d7b973
+  metadata.gz: 9197558d7b71582d339535933b2186c9ce3db7d0c4dd492759db5a226931ddf8
+  data.tar.gz: ccd05c4164478a54130c6bee32a234abbb2f193292438b8d35b6d7edd313802c
 SHA512:
-  metadata.gz: 50f4a4cd52039cd29d308676028a51fd7f44e25b89084e03c2ca570361c3c556f13bc924989415d04164967b63aadf0d88709c0f58289947fd2cf6a164f7f6dc
-  data.tar.gz: bd471eb79d28d9cf124452fe6e5608eb2a092800b4c49f1299348adf7a7c2a9d6a9bcd85da3f0cc6272753f743862e84b9777bab0cf095def8b9d1180a910e49
+  metadata.gz: b12528875d4b7d5b12739b1a37877d979bccc6d66f7a0006454ae260b1215eb69bb5baa2aae332e68bc4f1fa29859e4b00a427591cf78acf2aebc57264889a46
+  data.tar.gz: ae2baeaae67451740cc6773abbc79e4d0896baf96b99e7c2baebe027c1b7b05bbbbb75da5717be47c43d240835810a1681408e79c3d44449f7f44c3d4e8830a6

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.8.1] - 2025-01-15
+
+- Support for multiple database schemas, ensuring compatibility with multi-tenant applications using the apartment gem or similar solutions
+- DSL for configuring the gem, simplifying setup and customization
+- Rake task added to initialize the gem
+- Improved the post-checkout git hook to run only when switching branches, reducing unnecessary executions during file checkouts
+- Fixed the changelog link in the gemspec, ensuring Rubygems points to the correct file and the link works
+
+## [0.8.0] - 2024-12-30
+- Enhanced Console Visibility: Automatically rolled-back phantom migrations now provide clearer and more visible logs in the console
+- Git Hooks for Branch Management: Introduced hooks that automatically rollback phantom migrations after checking out a branch. Additionally, the schema migration rake task can now be executed automatically upon branch checkout
+- Temporary Folder Cleanup: Rolled-back phantom migrations are now automatically deleted from the temporary folder after rollback
+- Acronym Support in Phantom Migration Names: Resolved an issue where phantom migrations with acronyms in their names, defined in other branches, couldn't be rolled back automatically. These are now handled seamlessly
+
 ## [0.7.9] - 2024-09-07
 - Don't stop if a phantom migration rollback fails
 - Improve failed rollback of phantom migrations report

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    actual_db_schema (0.7.9)
+    actual_db_schema (0.8.1)
       activerecord
       activesupport
       csv
@@ -93,7 +93,7 @@ GEM
     concurrent-ruby (1.2.2)
     connection_pool (2.4.1)
     crass (1.0.6)
-    csv (3.3.0)
+    csv (3.3.2)
     date (3.3.3)
     debug (1.8.0)
       irb (>= 1.5.0)
@@ -222,6 +222,7 @@ GEM
     zeitwerk (2.6.12)
 
 PLATFORMS
+  arm64-darwin-22
   arm64-darwin-23
   x86_64-darwin-20
   x86_64-darwin-22

data/README.md

@@ -50,6 +50,16 @@ And then execute:
 
 If you cannot commit changes to the repo or Gemfile, consider the local Gemfile installation described in [this post](https://blog.widefix.com/personal-gemfile-for-development/).
 
+Next, generate your ActualDbSchema initializer file by running:
+
+```sh
+rake actual_db_schema:install
+```
+
+This will create a `config/initializers/actual_db_schema.rb` file with all the available configuration options so you can adjust them as needed. It will also prompt you to install the post-checkout Git hook for automatic phantom migration rollback when switching branches.
+
+For more details on the available configuration options, see the sections below.
+
 ## Usage
 
 Just run `rails db:migrate` inside the current branch. It will roll back all phantom migrations for all configured databases in your `database.yml.`
@@ -86,7 +96,7 @@ export ACTUAL_DB_SCHEMA_UI_ENABLED=true
 Add the following line to your initializer file (`config/initializers/actual_db_schema.rb`):
 
 ```ruby
-ActualDbSchema.config[:ui_enabled] = true
+config.ui_enabled = true
 ```
 
 > With this option, the UI can be disabled for all environments or be enabled in specific ones.
@@ -107,7 +117,55 @@ export ACTUAL_DB_SCHEMA_AUTO_ROLLBACK_DISABLED=true
 Add the following line to your initializer file (`config/initializers/actual_db_schema.rb`):
 
 ```ruby
-ActualDbSchema.config[:auto_rollback_disabled] = true
+config.auto_rollback_disabled = true
+```
+
+## Automatic Phantom Migration Rollback On Branch Switch
+
+By default, the automatic rollback of migrations on branch switch is disabled. If you prefer to automatically rollback phantom migrations whenever you switch branches with `git checkout`, you can enable it in two ways:
+
+### 1. Using Environment Variable
+
+Set the environment variable `ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED` to `true`:
+
+```sh
+export ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED=true
+```
+
+### 2. Using Initializer
+Add the following line to your initializer file (`config/initializers/actual_db_schema.rb`):
+
+```ruby
+config.git_hooks_enabled = true
+```
+
+### Installing the Post-Checkout Hook
+After enabling Git hooks in your configuration, run the rake task to install the post-checkout hook:
+
+```sh
+rake actual_db_schema:install_git_hooks
+```
+
+This task will prompt you to choose one of the three options:
+
+1. Rollback phantom migrations with `db:rollback_branches`
+2. Migrate up to the latest schema with `db:migrate`
+3. Skip installing git hook
+
+Based on your selection, a post-checkout hook will be installed or updated in your `.git/hooks` folder.
+
+## Multi-Tenancy Support
+
+If your application leverages multiple schemas for multi-tenancy — such as those implemented by the [apartment](https://github.com/influitive/apartment) gem or similar solutions — you can configure ActualDbSchema to handle migrations across all schemas. To do so, add the following configuration to your initializer file (`config/initializers/actual_db_schema.rb`):
+
+```ruby
+config.multi_tenant_schemas = -> { # list of all active schemas }
+```
+
+### Example:
+
+```ruby
+config.multi_tenant_schemas = -> { ["public", "tenant1", "tenant2"] }
 ```
 
 ## Development
@@ -148,6 +206,24 @@ To run tests with a specific version of Rails using Appraisal:
   bundle exec appraisal rails.6.0 rake test TEST=test/rake_task_test.rb TESTOPTS="--name=/db::db:rollback_branches#test_0003_keeps/"
   ```
 
+By default, `rake test` runs tests using `SQLite3`. To explicitly run tests with `SQLite3`, `PostgreSQL`, or `MySQL`, you can use the following tasks:
+- Run tests with `SQLite3`:
+  ```sh
+  bundle exec rake test:sqlite3
+  ```
+- Run tests with `PostgreSQL` (requires Docker):
+  ```sh
+  bundle exec rake test:postgresql
+  ```
+- Run tests with `MySQL` (requires Docker):
+  ```sh
+  bundle exec rake test:mysql2
+  ```
+- Run tests for all supported adapters:
+  ```sh
+  bundle exec rake test:all
+  ```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/widefix/actual_db_schema. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/widefix/actual_db_schema/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -3,6 +3,8 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
+load "lib/tasks/test.rake"
+
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"

data/actual_db_schema.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/widefix/actual_db_schema"
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["changelog_uri"] = "https://github.com/widefix/actual_db_schema/blob/main/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -44,6 +44,18 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rails"
   spec.add_development_dependency "sqlite3"
 
+  spec.post_install_message = <<~MSG
+    Thank you for installing ActualDbSchema!
+
+    Next steps:
+    1. Run `rake actual_db_schema:install` to generate the initializer file and install
+       the post-checkout Git hook for automatic phantom migration rollback when switching branches.
+    2. Or, if you prefer environment variables, skip this step.
+
+    For more information, see the README.
+
+  MSG
+
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
 end

data/docker/mysql-init/create_secondary_db.sql

@@ -0,0 +1 @@
+CREATE DATABASE actual_db_schema_test_secondary;

data/docker/postgres-init/create_secondary_db.sql

@@ -0,0 +1 @@
+CREATE DATABASE actual_db_schema_test_secondary;

data/docker-compose.yml

@@ -0,0 +1,23 @@
+version: '3.8'
+
+services:
+  postgres:
+    image: postgres:14
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: actual_db_schema_test
+    ports:
+      - "5432:5432"
+    volumes:
+      - ./docker/postgres-init:/docker-entrypoint-initdb.d
+
+  mysql:
+    image: mysql:8.0
+    environment:
+      MYSQL_ROOT_PASSWORD: password
+      MYSQL_DATABASE: actual_db_schema_test
+    ports:
+      - "3306:3306"
+    volumes:
+    - ./docker/mysql-init:/docker-entrypoint-initdb.d

data/gemfiles/rails.6.0.gemfile

@@ -7,6 +7,8 @@ source "https://rubygems.org"
 gem "activerecord", "~> 6.0.0"
 gem "activesupport", "~> 6.0.0"
 gem "minitest", "~> 5.0"
+gem "mysql2", "~> 0.5.2"
+gem "pg", "~> 1.5"
 gem "rake"
 gem "rubocop", "~> 1.21"
 gem "sqlite3", "~> 1.4.0"

data/gemfiles/rails.6.1.gemfile

@@ -7,6 +7,8 @@ source "https://rubygems.org"
 gem "activerecord", "~> 6.1.0"
 gem "activesupport", "~> 6.1.0"
 gem "minitest", "~> 5.0"
+gem "mysql2", "~> 0.5.2"
+gem "pg", "~> 1.5"
 gem "rake"
 gem "rubocop", "~> 1.21"
 gem "sqlite3", "~> 1.4.0"

data/gemfiles/rails.7.0.gemfile

@@ -7,6 +7,8 @@ source "https://rubygems.org"
 gem "activerecord", "~> 7.0.0"
 gem "activesupport", "~> 7.0.0"
 gem "minitest", "~> 5.0"
+gem "mysql2", "~> 0.5.2"
+gem "pg", "~> 1.5"
 gem "rake"
 gem "rubocop", "~> 1.21"
 gem "sqlite3", "~> 1.4.0"

data/gemfiles/rails.7.1.gemfile

@@ -7,6 +7,8 @@ source "https://rubygems.org"
 gem "activerecord", "~> 7.1.0"
 gem "activesupport", "~> 7.1.0"
 gem "minitest", "~> 5.0"
+gem "mysql2", "~> 0.5.2"
+gem "pg", "~> 1.5"
 gem "rake"
 gem "rubocop", "~> 1.21"
 gem "sqlite3", "~> 1.4.0"

data/gemfiles/rails.edge.gemfile

@@ -7,6 +7,8 @@ source "https://rubygems.org"
 gem "activerecord", ">= 7.2.0.beta"
 gem "activesupport", ">= 7.2.0.beta"
 gem "minitest", "~> 5.0"
+gem "mysql2", "~> 0.5.2"
+gem "pg", "~> 1.5"
 gem "rake"
 gem "rubocop", "~> 1.21"
 gem "rails", ">= 7.2.0.beta"

data/lib/actual_db_schema/commands/rollback.rb

@@ -4,11 +4,8 @@ module ActualDbSchema
   module Commands
     # Rolls back all phantom migrations
     class Rollback < Base
-      UNICODE_COLORS = {
-        red: 31,
-        green: 32,
-        yellow: 33
-      }.freeze
+      include ActualDbSchema::OutputFormatter
+      include ActionView::Helpers::TextHelper
 
       def initialize(context, manual_mode: false)
         @manual_mode = manual_mode || manual_mode_default?
@@ -18,50 +15,62 @@ module ActualDbSchema
       private
 
       def call_impl
-        context.rollback_branches(manual_mode: @manual_mode)
+        rolled_back = context.rollback_branches(manual_mode: @manual_mode)
 
-        return if ActualDbSchema.failed.empty?
+        return unless rolled_back || ActualDbSchema.failed.any?
 
-        puts_preamble
-        puts_into
-        puts ""
-        puts failed_migrations_list
-        puts_preamble
+        ActualDbSchema.failed.empty? ? print_success : print_error
+      end
+
+      def print_success
+        puts colorize("[ActualDbSchema] All phantom migrations rolled back successfully! 🎉", :green)
+      end
+
+      def print_error
+        header_message = <<~HEADER
+          #{ActualDbSchema.failed.count} phantom migration(s) could not be rolled back automatically.
+
+          Try these steps to fix and move forward:
+            1. Ensure the migrations are reversible (define #up and #down methods or use #reversible).
+            2. If the migration references code or tables from another branch, restore or remove them.
+            3. Once fixed, run `rails db:migrate` again.
+
+          Below are the details of the problematic migrations:
+        HEADER
+
+        print_error_summary("#{header_message}\n#{failed_migrations_list}")
       end
 
       def failed_migrations_list
         ActualDbSchema.failed.map.with_index(1) do |failed, index|
-          filename = failed.short_filename
-          exception = failed.exception
-          <<~MSG
-            \t#{colorize("[Migration##{index}]", :yellow)}
-            \t- #{filename}
-
-            \t\t#{exception.inspect.gsub("\n", "\n\t  ")}
-          MSG
-        end
+          migration_details = colorize("Migration ##{index}:\n", :yellow)
+          migration_details += "  File: #{failed.short_filename}\n"
+          migration_details += "  Schema: #{failed.schema}\n" if failed.schema
+          migration_details + "  Branch: #{failed.branch}\n"
+        end.join("\n")
       end
 
-      def puts_preamble
-        puts ""
-        puts %(\u2757\u2757\u2757 #{colorize("[ActualDbSchema]", :red)})
-        puts ""
+      def print_error_summary(content)
+        width = 100
+        indent = 4
+        gem_name = "ActualDbSchema"
+
+        puts colorize("╔═ [#{gem_name}] #{"═" * (width - gem_name.length - 5)}╗", :red)
+        print_wrapped_content(content, width, indent)
+        puts colorize("╚#{"═" * width}╝", :red)
       end
 
-      def puts_into
-        msg = "#{ActualDbSchema.failed.count} phantom migration(s) could not be rolled back automatically."
-        msg += " Roll them back or fix manually:"
-        puts colorize(msg, :red)
+      def print_wrapped_content(content, width, indent)
+        usable_width = width - indent - 4
+        wrapped_content = word_wrap(content, line_width: usable_width)
+        wrapped_content.each_line do |line|
+          puts "#{" " * indent}#{line.chomp}"
+        end
       end
 
       def manual_mode_default?
         ActualDbSchema.config[:auto_rollback_disabled]
       end
-
-      def colorize(text, color)
-        code = UNICODE_COLORS.fetch(color, 37)
-        "\e[#{code}m#{text}\e[0m"
-      end
     end
   end
 end

data/lib/actual_db_schema/configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActualDbSchema
+  # Manages the configuration settings for the gem.
+  class Configuration
+    attr_accessor :enabled, :auto_rollback_disabled, :ui_enabled, :git_hooks_enabled, :multi_tenant_schemas
+
+    def initialize
+      @enabled = Rails.env.development?
+      @auto_rollback_disabled = ENV["ACTUAL_DB_SCHEMA_AUTO_ROLLBACK_DISABLED"].present?
+      @ui_enabled = Rails.env.development? || ENV["ACTUAL_DB_SCHEMA_UI_ENABLED"].present?
+      @git_hooks_enabled = ENV["ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED"].present?
+      @multi_tenant_schemas = nil
+    end
+
+    def [](key)
+      public_send(key)
+    end
+
+    def []=(key, value)
+      public_send("#{key}=", value)
+    end
+
+    def fetch(key, default = nil)
+      if respond_to?(key)
+        public_send(key)
+      else
+        default
+      end
+    end
+  end
+end

data/lib/actual_db_schema/failed_migration.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActualDbSchema
-  FailedMigration = Struct.new(:migration, :exception, keyword_init: true) do
+  FailedMigration = Struct.new(:migration, :exception, :branch, :schema, keyword_init: true) do
     def filename
       migration.filename
     end

data/lib/actual_db_schema/git_hooks.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module ActualDbSchema
+  # Handles the installation of a git post-checkout hook that rolls back phantom migrations when switching branches
+  class GitHooks # rubocop:disable Metrics/ClassLength
+    include ActualDbSchema::OutputFormatter
+
+    POST_CHECKOUT_MARKER_START = "# >>> BEGIN ACTUAL_DB_SCHEMA"
+    POST_CHECKOUT_MARKER_END   = "# <<< END ACTUAL_DB_SCHEMA"
+
+    POST_CHECKOUT_HOOK_ROLLBACK = <<~BASH
+      #{POST_CHECKOUT_MARKER_START}
+      # ActualDbSchema post-checkout hook (ROLLBACK)
+      # Runs db:rollback_branches on branch checkout.
+
+      # Check if this is a file checkout or creating a new branch
+      if [ "$3" == "0" ] || [ "$1" == "$2" ]; then
+        exit 0
+      fi
+
+      if [ -f ./bin/rails ]; then
+        if [ -n "$ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED" ]; then
+          GIT_HOOKS_ENABLED="$ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED"
+        else
+          GIT_HOOKS_ENABLED=$(./bin/rails runner "puts ActualDbSchema.config[:git_hooks_enabled]" 2>/dev/null)
+        fi
+
+        if [ "$GIT_HOOKS_ENABLED" == "true" ]; then
+          ./bin/rails db:rollback_branches
+        fi
+      fi
+      #{POST_CHECKOUT_MARKER_END}
+    BASH
+
+    POST_CHECKOUT_HOOK_MIGRATE = <<~BASH
+      #{POST_CHECKOUT_MARKER_START}
+      # ActualDbSchema post-checkout hook (MIGRATE)
+      # Runs db:migrate on branch checkout.
+
+      # Check if this is a file checkout or creating a new branch
+      if [ "$3" == "0" ] || [ "$1" == "$2" ]; then
+        exit 0
+      fi
+
+      if [ -f ./bin/rails ]; then
+        if [ -n "$ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED" ]; then
+          GIT_HOOKS_ENABLED="$ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED"
+        else
+          GIT_HOOKS_ENABLED=$(./bin/rails runner "puts ActualDbSchema.config[:git_hooks_enabled]" 2>/dev/null)
+        fi
+
+        if [ "$GIT_HOOKS_ENABLED" == "true" ]; then
+          ./bin/rails db:migrate
+        fi
+      fi
+      #{POST_CHECKOUT_MARKER_END}
+    BASH
+
+    def initialize(strategy: :rollback)
+      @strategy = strategy
+    end
+
+    def install_post_checkout_hook
+      return unless git_hooks_enabled?
+      return unless hooks_directory_present?
+
+      if File.exist?(hook_path)
+        handle_existing_hook
+      else
+        create_new_hook
+      end
+    end
+
+    private
+
+    def hook_code
+      @strategy == :migrate ? POST_CHECKOUT_HOOK_MIGRATE : POST_CHECKOUT_HOOK_ROLLBACK
+    end
+
+    def hooks_dir
+      @hooks_dir ||= Rails.root.join(".git", "hooks")
+    end
+
+    def hook_path
+      @hook_path ||= hooks_dir.join("post-checkout")
+    end
+
+    def git_hooks_enabled?
+      return true if ActualDbSchema.config[:git_hooks_enabled]
+
+      puts colorize("[ActualDbSchema] Git hooks are disabled in configuration. Skipping installation.", :gray)
+    end
+
+    def hooks_directory_present?
+      return true if Dir.exist?(hooks_dir)
+
+      puts colorize("[ActualDbSchema] .git/hooks directory not found. Please ensure this is a Git repository.", :gray)
+    end
+
+    def handle_existing_hook
+      return update_hook if markers_exist?
+      return install_hook if safe_install?
+
+      show_manual_install_instructions
+    end
+
+    def create_new_hook
+      contents = <<~BASH
+        #!/usr/bin/env bash
+
+        #{hook_code}
+      BASH
+
+      write_hook_file(contents)
+      print_success
+    end
+
+    def markers_exist?
+      contents = File.read(hook_path)
+      contents.include?(POST_CHECKOUT_MARKER_START) && contents.include?(POST_CHECKOUT_MARKER_END)
+    end
+
+    def update_hook
+      contents = File.read(hook_path)
+      new_contents = replace_marker_contents(contents)
+
+      if new_contents == contents
+        message = "[ActualDbSchema] post-checkout git hook already contains the necessary code. Nothing to update."
+        puts colorize(message, :gray)
+      else
+        write_hook_file(new_contents)
+        puts colorize("[ActualDbSchema] post-checkout git hook updated successfully at #{hook_path}", :green)
+      end
+    end
+
+    def replace_marker_contents(contents)
+      contents.gsub(
+        /#{Regexp.quote(POST_CHECKOUT_MARKER_START)}.*#{Regexp.quote(POST_CHECKOUT_MARKER_END)}/m,
+        hook_code.strip
+      )
+    end
+
+    def safe_install?
+      puts colorize("[ActualDbSchema] A post-checkout hook already exists at #{hook_path}.", :gray)
+      puts "Overwrite the existing hook at #{hook_path}? [y,n] "
+
+      answer = $stdin.gets.chomp.downcase
+      answer.start_with?("y")
+    end
+
+    def install_hook
+      contents = File.read(hook_path)
+      new_contents = <<~BASH
+        #{contents.rstrip}
+
+        #{hook_code}
+      BASH
+
+      write_hook_file(new_contents)
+      print_success
+    end
+
+    def show_manual_install_instructions
+      puts colorize("[ActualDbSchema] You can follow these steps to manually install the hook:", :yellow)
+      puts <<~MSG
+
+        1. Open the existing post-checkout hook at:
+           #{hook_path}
+
+        2. Insert the following lines into that file (preferably at the end or in a relevant section).
+           Make sure you include the #{POST_CHECKOUT_MARKER_START} and #{POST_CHECKOUT_MARKER_END} lines:
+
+        #{hook_code}
+
+        3. Ensure the post-checkout file is executable:
+           chmod +x #{hook_path}
+
+        4. Done! Now when you switch branches, phantom migrations will be rolled back automatically (if enabled).
+
+      MSG
+    end
+
+    def write_hook_file(contents)
+      File.open(hook_path, "w") { |file| file.write(contents) }
+      FileUtils.chmod("+x", hook_path)
+    end
+
+    def print_success
+      puts colorize("[ActualDbSchema] post-checkout git hook installed successfully at #{hook_path}", :green)
+    end
+  end
+end

data/lib/actual_db_schema/multi_tenant.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ActualDbSchema
+  # Handles multi-tenancy support by switching schemas for supported databases
+  module MultiTenant
+    include ActualDbSchema::OutputFormatter
+
+    class << self
+      def with_schema(schema_name)
+        context = switch_schema(schema_name)
+        yield
+      ensure
+        restore_context(context)
+      end
+
+      private
+
+      def adapter_name
+        ActiveRecord::Base.connection.adapter_name
+      end
+
+      def switch_schema(schema_name)
+        case adapter_name
+        when /postgresql/i
+          switch_postgresql_schema(schema_name)
+        when /mysql/i
+          switch_mysql_schema(schema_name)
+        else
+          message = "[ActualDbSchema] Multi-tenancy not supported for adapter: #{adapter_name}. " \
+            "Proceeding without schema switching."
+          puts colorize(message, :gray)
+        end
+      end
+
+      def switch_postgresql_schema(schema_name)
+        old_search_path = ActiveRecord::Base.connection.schema_search_path
+        ActiveRecord::Base.connection.schema_search_path = schema_name
+        { type: :postgresql, old_context: old_search_path }
+      end
+
+      def switch_mysql_schema(schema_name)
+        old_db = ActiveRecord::Base.connection.current_database
+        ActiveRecord::Base.connection.execute("USE #{ActiveRecord::Base.connection.quote_table_name(schema_name)}")
+        { type: :mysql, old_context: old_db }
+      end
+
+      def restore_context(context)
+        return unless context
+
+        case context[:type]
+        when :postgresql
+          ActiveRecord::Base.connection.schema_search_path = context[:old_context] if context[:old_context]
+        when :mysql
+          return unless context[:old_context]
+
+          ActiveRecord::Base.connection.execute(
+            "USE #{ActiveRecord::Base.connection.quote_table_name(context[:old_context])}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/actual_db_schema/output_formatter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActualDbSchema
+  # Provides functionality for formatting terminal output with colors
+  module OutputFormatter
+    UNICODE_COLORS = {
+      red: 31,
+      green: 32,
+      yellow: 33,
+      gray: 90
+    }.freeze
+
+    def colorize(text, color)
+      code = UNICODE_COLORS.fetch(color, 37)
+      "\e[#{code}m#{text}\e[0m"
+    end
+  end
+end

data/lib/actual_db_schema/patches/migration_context.rb

@@ -3,16 +3,21 @@
 module ActualDbSchema
   module Patches
     # Add new command to roll back the phantom migrations
-    module MigrationContext
+    module MigrationContext # rubocop:disable Metrics/ModuleLength
+      include ActualDbSchema::OutputFormatter
+
       def rollback_branches(manual_mode: false)
-        phantom_migrations.reverse_each do |migration|
-          next unless status_up?(migration)
+        schemas = multi_tenant_schemas&.call || []
+        schema_count = schemas.any? ? schemas.size : 1
 
-          show_info_for(migration) if manual_mode
-          migrate(migration) if !manual_mode || user_wants_rollback?
-        rescue StandardError => e
-          ActualDbSchema.failed << FailedMigration.new(migration: migration, exception: e)
-        end
+        rolled_back_migrations = if schemas.any?
+                                   rollback_multi_tenant(schemas, manual_mode: manual_mode)
+                                 else
+                                   rollback_branches_for_schema(manual_mode: manual_mode)
+                                 end
+
+        delete_migrations(rolled_back_migrations, schema_count)
+        rolled_back_migrations.any?
       end
 
       def phantom_migrations
@@ -27,6 +32,32 @@ module ActualDbSchema
 
       private
 
+      def rollback_branches_for_schema(manual_mode: false, schema_name: nil, rolled_back_migrations: [])
+        phantom_migrations.reverse_each do |migration|
+          next unless status_up?(migration)
+
+          show_info_for(migration, schema_name) if manual_mode
+          migrate(migration, rolled_back_migrations, schema_name) if !manual_mode || user_wants_rollback?
+        rescue StandardError => e
+          handle_rollback_error(migration, e, schema_name)
+        end
+
+        rolled_back_migrations
+      end
+
+      def rollback_multi_tenant(schemas, manual_mode: false)
+        all_rolled_back_migrations = []
+
+        schemas.each do |schema_name|
+          ActualDbSchema::MultiTenant.with_schema(schema_name) do
+            rollback_branches_for_schema(manual_mode: manual_mode, schema_name: schema_name,
+                                         rolled_back_migrations: all_rolled_back_migrations)
+          end
+        end
+
+        all_rolled_back_migrations
+      end
+
       def down_migrator_for(migration)
         if ActiveRecord::Migration.current_version < 6
           ActiveRecord::Migrator.new(:down, [migration], migration.version)
@@ -62,19 +93,34 @@ module ActualDbSchema
         answer[0] == "y"
       end
 
-      def show_info_for(migration)
-        puts "\n[ActualDbSchema] A phantom migration was found and is about to be rolled back."
+      def show_info_for(migration, schema_name = nil)
+        puts colorize("\n[ActualDbSchema] A phantom migration was found and is about to be rolled back.", :gray)
         puts "Please make a decision from the options below to proceed.\n\n"
+        puts "Schema: #{schema_name}" if schema_name
         puts "Branch: #{branch_for(migration.version.to_s)}"
         puts "Database: #{ActualDbSchema.db_config[:database]}"
         puts "Version: #{migration.version}\n\n"
         puts File.read(migration.filename)
       end
 
-      def migrate(migration)
+      def migrate(migration, rolled_back_migrations, schema_name = nil)
+        migration.name = extract_class_name(migration.filename)
+
+        message = "[ActualDbSchema]"
+        message += " #{schema_name}:" if schema_name
+        message += " Rolling back phantom migration #{migration.version} #{migration.name} " \
+                   "(from branch: #{branch_for(migration.version.to_s)})"
+        puts colorize(message, :gray)
+
         migrator = down_migrator_for(migration)
         migrator.extend(ActualDbSchema::Patches::Migrator)
         migrator.migrate
+        rolled_back_migrations << migration
+      end
+
+      def extract_class_name(filename)
+        content = File.read(filename)
+        content.match(/^class\s+([A-Za-z0-9_]+)\s+</)[1]
       end
 
       def branch_for(version)
@@ -84,6 +130,46 @@ module ActualDbSchema
       def metadata
         @metadata ||= ActualDbSchema::Store.instance.read
       end
+
+      def handle_rollback_error(migration, exception, schema_name = nil)
+        error_message = <<~ERROR
+          Error encountered during rollback:
+
+          #{cleaned_exception_message(exception.message)}
+        ERROR
+
+        puts colorize(error_message, :red)
+        ActualDbSchema.failed << FailedMigration.new(
+          migration: migration,
+          exception: exception,
+          branch: branch_for(migration.version.to_s),
+          schema: schema_name
+        )
+      end
+
+      def cleaned_exception_message(message)
+        patterns_to_remove = [
+          /^An error has occurred, all later migrations canceled:\s*/,
+          /^An error has occurred, this and all later migrations canceled:\s*/
+        ]
+
+        patterns_to_remove.reduce(message.strip) { |msg, pattern| msg.gsub(pattern, "").strip }
+      end
+
+      def delete_migrations(migrations, schema_count)
+        migration_counts = migrations.each_with_object(Hash.new(0)) do |migration, hash|
+          hash[migration.filename] += 1
+        end
+
+        migrations.uniq.each do |migration|
+          count = migration_counts[migration.filename]
+          File.delete(migration.filename) if count == schema_count && File.exist?(migration.filename)
+        end
+      end
+
+      def multi_tenant_schemas
+        ActualDbSchema.config[:multi_tenant_schemas]
+      end
     end
   end
 end

data/lib/actual_db_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActualDbSchema
-  VERSION = "0.7.9"
+  VERSION = "0.8.1"
 end

data/lib/actual_db_schema.rb

@@ -4,14 +4,18 @@ require "actual_db_schema/engine"
 require "active_record/migration"
 require "csv"
 require_relative "actual_db_schema/git"
+require_relative "actual_db_schema/configuration"
 require_relative "actual_db_schema/store"
 require_relative "actual_db_schema/version"
 require_relative "actual_db_schema/migration"
 require_relative "actual_db_schema/failed_migration"
 require_relative "actual_db_schema/migration_context"
+require_relative "actual_db_schema/output_formatter"
 require_relative "actual_db_schema/patches/migration_proxy"
 require_relative "actual_db_schema/patches/migrator"
 require_relative "actual_db_schema/patches/migration_context"
+require_relative "actual_db_schema/git_hooks"
+require_relative "actual_db_schema/multi_tenant"
 
 require_relative "actual_db_schema/commands/base"
 require_relative "actual_db_schema/commands/rollback"
@@ -26,11 +30,11 @@ module ActualDbSchema
   end
 
   self.failed = []
-  self.config = {
-    enabled: Rails.env.development?,
-    auto_rollback_disabled: ENV["ACTUAL_DB_SCHEMA_AUTO_ROLLBACK_DISABLED"].present?,
-    ui_enabled: Rails.env.development? || ENV["ACTUAL_DB_SCHEMA_UI_ENABLED"].present?
-  }
+  self.config = Configuration.new
+
+  def self.configure
+    yield(config)
+  end
 
   def self.migrated_folder
     migrated_folders.first

data/lib/generators/actual_db_schema/templates/actual_db_schema.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# ActualDbSchema initializer
+# Adjust the configuration as needed.
+
+ActualDbSchema.configure do |config|
+  # Enable the gem.
+  config.enabled = Rails.env.development?
+
+  # Disable automatic rollback of phantom migrations.
+  # config.auto_rollback_disabled = true
+  config.auto_rollback_disabled = ENV["ACTUAL_DB_SCHEMA_AUTO_ROLLBACK_DISABLED"].present?
+
+  # Enable the UI for managing migrations.
+  config.ui_enabled = Rails.env.development? || ENV["ACTUAL_DB_SCHEMA_UI_ENABLED"].present?
+
+  # Enable automatic phantom migration rollback on branch switch,
+  # config.git_hooks_enabled = true
+  config.git_hooks_enabled = ENV["ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED"].present?
+
+  # If your application leverages multiple schemas for multi-tenancy, define the active schemas.
+  # config.multi_tenant_schemas = -> { ["public", "tenant1", "tenant2"] }
+end

data/lib/tasks/actual_db_schema.rake

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+namespace :actual_db_schema do # rubocop:disable Metrics/BlockLength
+  desc "Install ActualDbSchema initializer and post-checkout git hook."
+  task :install do
+    extend ActualDbSchema::OutputFormatter
+
+    initializer_path = Rails.root.join("config", "initializers", "actual_db_schema.rb")
+    initializer_content = File.read(
+      File.expand_path("../../lib/generators/actual_db_schema/templates/actual_db_schema.rb", __dir__)
+    )
+
+    if File.exist?(initializer_path)
+      puts colorize("[ActualDbSchema] An initializer already exists at #{initializer_path}.", :gray)
+      puts "Overwrite the existing file at #{initializer_path}? [y,n] "
+      answer = $stdin.gets.chomp.downcase
+
+      if answer.start_with?("y")
+        File.write(initializer_path, initializer_content)
+        puts colorize("[ActualDbSchema] Initializer updated successfully at #{initializer_path}", :green)
+      else
+        puts colorize("[ActualDbSchema] Skipped overwriting the initializer.", :yellow)
+      end
+    else
+      File.write(initializer_path, initializer_content)
+      puts colorize("[ActualDbSchema] Initializer created successfully at #{initializer_path}", :green)
+    end
+
+    Rake::Task["actual_db_schema:install_git_hooks"].invoke
+  end
+
+  desc "Install ActualDbSchema post-checkout git hook that rolls back phantom migrations when switching branches."
+  task :install_git_hooks do
+    extend ActualDbSchema::OutputFormatter
+
+    puts "Which Git hook strategy would you like to install? [1, 2, 3]"
+    puts "  1) Rollback phantom migrations (db:rollback_branches)"
+    puts "  2) Migrate up to latest (db:migrate)"
+    puts "  3) No hook installation (skip)"
+    answer = $stdin.gets.chomp
+
+    strategy =
+      case answer
+      when "1" then :rollback
+      when "2" then :migrate
+      else
+        :none
+      end
+
+    if strategy == :none
+      puts colorize("[ActualDbSchema] Skipping git hook installation.", :gray)
+    else
+      ActualDbSchema::GitHooks.new(strategy: strategy).install_post_checkout_hook
+    end
+  end
+end

data/lib/tasks/test.rake

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+namespace :test do # rubocop:disable Metrics/BlockLength
+  desc "Run tests with SQLite3"
+  task :sqlite3 do
+    ENV["DB_ADAPTER"] = "sqlite3"
+    Rake::Task["test"].invoke
+    Rake::Task["test"].reenable
+  end
+
+  desc "Run tests with PostgreSQL"
+  task :postgresql do
+    sh "docker-compose up -d postgres"
+    wait_for_postgres
+
+    begin
+      ENV["DB_ADAPTER"] = "postgresql"
+      Rake::Task["test"].invoke
+      Rake::Task["test"].reenable
+    ensure
+      sh "docker-compose down"
+    end
+  end
+
+  desc "Run tests with MySQL"
+  task :mysql2 do
+    sh "docker-compose up -d mysql"
+    wait_for_mysql
+
+    begin
+      ENV["DB_ADAPTER"] = "mysql2"
+      Rake::Task["test"].invoke
+      Rake::Task["test"].reenable
+    ensure
+      sh "docker-compose down"
+    end
+  end
+
+  desc "Run tests with all adapters (SQLite3, PostgreSQL, MySQL)"
+  task all: %i[sqlite3 postgresql mysql2]
+
+  def wait_for_postgres
+    retries = 10
+    begin
+      sh "docker-compose exec -T postgres pg_isready -U postgres"
+    rescue StandardError
+      retries -= 1
+
+      raise "PostgreSQL is not ready after several attempts." if retries < 1
+
+      sleep 2
+      retry
+    end
+  end
+
+  def wait_for_mysql
+    retries = 10
+    begin
+      sh "docker-compose exec -T mysql mysqladmin ping -h 127.0.0.1 --silent"
+    rescue StandardError
+      retries -= 1
+
+      raise "MySQL is not ready after several attempts." if retries < 1
+
+      sleep 2
+      retry
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actual_db_schema
 version: !ruby/object:Gem::Version
-  version: 0.7.9
+  version: 0.8.1
 platform: ruby
 authors:
 - Andrei Kaleshka
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-06 00:00:00.000000000 Z
+date: 2025-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -136,6 +136,9 @@ files:
 - app/views/actual_db_schema/shared/_js.html
 - app/views/actual_db_schema/shared/_style.html
 - config/routes.rb
+- docker-compose.yml
+- docker/mysql-init/create_secondary_db.sql
+- docker/postgres-init/create_secondary_db.sql
 - gemfiles/rails.6.0.gemfile
 - gemfiles/rails.6.1.gemfile
 - gemfiles/rails.7.0.gemfile
@@ -145,17 +148,24 @@ files:
 - lib/actual_db_schema/commands/base.rb
 - lib/actual_db_schema/commands/list.rb
 - lib/actual_db_schema/commands/rollback.rb
+- lib/actual_db_schema/configuration.rb
 - lib/actual_db_schema/engine.rb
 - lib/actual_db_schema/failed_migration.rb
 - lib/actual_db_schema/git.rb
+- lib/actual_db_schema/git_hooks.rb
 - lib/actual_db_schema/migration.rb
 - lib/actual_db_schema/migration_context.rb
+- lib/actual_db_schema/multi_tenant.rb
+- lib/actual_db_schema/output_formatter.rb
 - lib/actual_db_schema/patches/migration_context.rb
 - lib/actual_db_schema/patches/migration_proxy.rb
 - lib/actual_db_schema/patches/migrator.rb
 - lib/actual_db_schema/store.rb
 - lib/actual_db_schema/version.rb
+- lib/generators/actual_db_schema/templates/actual_db_schema.rb
+- lib/tasks/actual_db_schema.rake
 - lib/tasks/db.rake
+- lib/tasks/test.rake
 - sig/actual_db_schema.rbs
 homepage: https://blog.widefix.com/actual-db-schema/
 licenses:
@@ -163,8 +173,17 @@ licenses:
 metadata:
   homepage_uri: https://blog.widefix.com/actual-db-schema/
   source_code_uri: https://github.com/widefix/actual_db_schema
-  changelog_uri: https://blog.widefix.com/actual-db-schema//blob/main/CHANGELOG.md
-post_install_message:
+  changelog_uri: https://github.com/widefix/actual_db_schema/blob/main/CHANGELOG.md
+post_install_message: |+
+  Thank you for installing ActualDbSchema!
+
+  Next steps:
+  1. Run `rake actual_db_schema:install` to generate the initializer file and install
+     the post-checkout Git hook for automatic phantom migration rollback when switching branches.
+  2. Or, if you prefer environment variables, skip this step.
+
+  For more information, see the README.
+
 rdoc_options: []
 require_paths:
 - lib
@@ -184,3 +203,4 @@ signing_key:
 specification_version: 4
 summary: Keep your DB and schema.rb consistent in dev branches.
 test_files: []
+...