after_migrate 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2602aa9ee3d2ffa2c1ea85ca8cbfa1b101679aa42ed05e0a4cfa4c742f258f59
-  data.tar.gz: d581242202742eb6a62be1cd1799a49c196ca82c99e8b36428ee6390fd12c415
+  metadata.gz: 19aeb8ce5d84227e4ea467f7e0d14ff8ccdb34f49214f9201b7550ede7ffbbf3
+  data.tar.gz: 2c52a7d680cb37bc2536be8ccd822fee3b92fc6e2b91a5587fa7da1826d14993
 SHA512:
-  metadata.gz: d81dce8555f469b190b3cfd37f7eb2b919aab714e6fcfb1842271c323495b213be2c2e779c8400ad67d28832c11dbc7ad7147e90f93b6950069b6b6b9ea8d558
-  data.tar.gz: 77f23e51b264cf80b5cbf028a0e43106d13498f9f7d109b1eafe26c6380269c08bb3574946ec534d08b8ac175a09c008823e64d0c862c4e4441e66c1df145399
+  metadata.gz: f8f671d511d7dc8cecc9a33e8bd90752cd0bb5b5ccb50a485dd7215c50ee68d76ec9ce626850d18717bb507a50e0bfe31e71425d24975607144b3749da1d9345
+  data.tar.gz: 80e42d103e33f52644366ebd660a0d5252c55934386830c68f33c9418b37ffbb92310c1c2dc2dd033d9a62204f0bd8d8c78f222852796d5838c4526ae313809e

data/.gitignore

@@ -9,3 +9,5 @@
 
 # rspec failure tracking
 .rspec_status
+.idea/
+/Gemfile.lock

data/.rubocop.yml

@@ -1,2 +1,14 @@
 AllCops:
   NewCops: enable
+  SuggestExtensions: false
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 20
+
+Metrics/BlockLength:
+  Exclude:
+    - 'after_migrate.gemspec'
+    - 'spec/**/*.rb'

data/.ruby-version

@@ -1 +1 @@
-3.4.7
+3.4.9

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.2.0] - 2026-04-28
+
+### Added
+- `defer` configuration option (default: `true`) — when enabled, rake task enhancements only collect touched tables; they do not run maintenance automatically
+- `AfterMigrate.run!` public API to explicitly trigger maintenance on all collected tables across all schemas, then clear the store — intended to be called once after all tenant migrations complete in multi-tenant setups
+- `after_migrate:run` rake task as a convenience wrapper around `AfterMigrate.run!`
+
+### Changed
+- **Breaking**: replaced `AfterMigrate::Current` (`ActiveSupport::CurrentAttributes`) with a module-level persistent store (`Concurrent::Map`). The store accumulates touched tables across multiple rake task invocations and only resets when `AfterMigrate.run!` is called.
+- Fixed `all_tables` analyze mode - previously iterated `.each_value` (yielding `Concurrent::Set` objects) instead of schema names, producing incorrect SQL queries.
+
+### Removed
+- `AfterMigrate::Current` - no longer needed. If you referenced this class directly, use `AfterMigrate.affected_tables` instead.
+- `Executor.call(reset:)` parameter - the store is always cleared after `run!`; pass `schema:` to scope execution to a single schema.
+
 ## [0.1.0] - 2025-04-05
 
 ### Added

data/CLAUDE.md

@@ -0,0 +1,74 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+```bash
+bundle install          # install dependencies
+bundle exec rspec       # run all tests
+bundle exec rspec spec/after_migrate_spec.rb  # run a single spec file
+bundle exec rake        # default task (runs spec)
+bundle exec rubocop     # lint
+bundle exec rubocop -a  # lint with auto-fix
+rake release            # build and push gem to RubyGems
+```
+
+## Architecture
+
+This is a Rails gem that automatically runs database maintenance (`ANALYZE`, `VACUUM`, `PRAGMA optimize`) after `db:migrate` tasks. The core flow is:
+
+1. **`Railtie`** (`lib/after_migrate/railtie.rb`) — the entry point. On Rails init, it subscribes to `sql.active_record` notifications so every SQL statement during a migration is intercepted. It enhances `db:migrate`, `db:migrate:up`, and `db:migrate:redo` to call `AfterMigrate.run!` when they complete — unless `defer: true` (the default), in which case the rake task only collects. It also registers the `after_migrate:run` task.
+
+2. **`Collector`** (`lib/after_migrate/collector.rb`) — receives every SQL notification, filters to DDL/DML statements (CREATE/ALTER/DROP/INSERT/UPDATE/DELETE), calls the adapter-specific parser, and accumulates table names into `AfterMigrate.affected_tables` (a `Concurrent::Map<schema, Concurrent::Set<table_name>>`).
+
+3. **`AfterMigrate.affected_tables`** (module-level store in `lib/after_migrate.rb`) — a `Concurrent::Map` that persists across multiple rake task invocations. Only cleared when `AfterMigrate.run!` (or `AfterMigrate.reset!`) is called. This replaces the old `Current` (`ActiveSupport::CurrentAttributes`) which was reset after every migration.
+
+4. **`Executor`** (`lib/after_migrate/executor.rb`) — iterates `AfterMigrate.affected_tables` and calls the correct adapter's `optimize_tables`. Respects the `analyze` config option (`only_affected_tables` / `all_tables` / `none`). Always calls `AfterMigrate.reset!` in its `ensure` block.
+
+5. **Adapters** (`lib/after_migrate/adapters/`) — one module per database:
+   - `Sql` — shared regex-based table parser (used by MySQL and SQLite, which can't use pg_query)
+   - `Postgresql` — uses `pg_query` gem for accurate SQL parsing; runs `VACUUM` (checking `pg_stat_all_tables` for dead tuples) then `ANALYZE VERBOSE` per table
+   - `Mysql` — runs `ANALYZE TABLE` per table; lists tables from `information_schema`
+   - `Sqlite` — runs `PRAGMA optimize` (SQLite ≥ 3.35.0) or `VACUUM; ANALYZE;`
+
+## Key design decisions
+
+- PostgreSQL uses `pg_query` (the actual Postgres parser) for table extraction, which avoids false positives from regex. MySQL and SQLite fall back to the shared `Sql` regex patterns.
+- `pg_query` is a hard runtime dependency (listed in gemspec), not optional — even though it's only used for PostgreSQL.
+- Table collection uses `Concurrent::Map` + `Concurrent::Set` (from `concurrent-ruby`) for thread-safe accumulation across parallel migration workers.
+- The gem does **not** monkey-patch ActiveRecord. It only uses public `ActiveSupport::Notifications` and `Rake::Task#enhance` APIs.
+- `defer: true` (the default) is the multi-tenant-friendly mode: rake tasks only collect, never execute. Call `AfterMigrate.run!` (or `rake after_migrate:run`) once after all tenant migrations complete.
+- The `app.executor.to_run` unsubscription in `Railtie` ensures the SQL subscription is dropped before the app starts serving web requests, so normal traffic is never collected.
+
+## Configuration
+
+Config values are in `AfterMigrate::Configuration` (initialized in `lib/after_migrate.rb`):
+
+| Option                | Default                  | Values                                             |
+|-----------------------|--------------------------|----------------------------------------------------|
+| `enabled`             | `true`                   | bool                                               |
+| `verbose`             | `true`                   | bool                                               |
+| `vacuum`              | `true`                   | bool (PostgreSQL only)                             |
+| `analyze`             | `"only_affected_tables"` | `"only_affected_tables"`, `"all_tables"`, `"none"` |
+| `rake_tasks_enhanced` | `true`                   | bool                                               |
+| `defer`               | `true`                   | bool — skip auto-run; call `AfterMigrate.run!` manually |
+
+## Multi-tenant usage
+
+```ruby
+# In your tenant migration runner:
+Tenant.each do |tenant|
+  tenant.switch { ActiveRecord::MigrationContext.new(...).migrate }
+end
+# Tables are now accumulated per schema in AfterMigrate.affected_tables
+AfterMigrate.run!           # or: Rake::Task['after_migrate:run'].invoke
+```
+
+Set `defer: false` to restore the v0.1 behaviour of running after each `db:migrate`.
+
+## Dependencies
+
+- Ruby ≥ 3.2, Rails ≥ 7.0
+- `pg_query ≥ 6.1` (required even for non-Postgres installs)
+- Dev: `rspec ~> 3.0`, `rubocop ~> 1.81`, `bundler ~> 4`

data/README.md

@@ -83,6 +83,30 @@ end
 ```
 ---
 
+## 🚢 Releasing
+
+Use the guarded helper to make sure git is pushed before RubyGems publish:
+
+```bash
+bin/release
+```
+
+What it does:
+- requires a clean git worktree
+- ensures you are on the default branch (`origin/HEAD` fallback)
+- checks branch sync status vs `origin`
+- runs `bundle exec rspec` and `bundle exec rubocop`
+- pushes the branch first
+- runs `bundle exec rake release` (build/tag/push/publish)
+
+Optional:
+
+```bash
+bin/release --skip-checks
+```
+
+---
+
 ## 🤝 Contributing
 
 Bug reports, feature requests, and pull requests are very welcome!

data/bin/release

@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+
+root_dir=$(cd "$(dirname "$0")/.." && pwd)
+cd "$root_dir"
+
+if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
+  cat <<'USAGE'
+Usage: bin/release [--skip-checks]
+
+Runs guardrails before releasing:
+1. Requires a clean git worktree
+2. Requires current branch to match origin/HEAD (or local HEAD fallback)
+3. Requires branch to be in sync with origin
+4. Runs test + lint checks (unless --skip-checks)
+5. Pushes the branch, then runs `bundle exec rake release`
+USAGE
+  exit 0
+fi
+
+skip_checks=false
+if [[ "${1:-}" == "--skip-checks" ]]; then
+  skip_checks=true
+elif [[ $# -gt 0 ]]; then
+  echo "Unknown option: $1" >&2
+  exit 1
+fi
+
+if [[ -n "$(git status --porcelain)" ]]; then
+  echo "Working tree is not clean. Commit or stash changes before releasing." >&2
+  exit 1
+fi
+
+current_branch=$(git rev-parse --abbrev-ref HEAD)
+default_branch=$(git symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null | sed 's|^origin/||')
+default_branch=${default_branch:-$current_branch}
+
+if [[ "$current_branch" != "$default_branch" ]]; then
+  echo "Release must run from '$default_branch' (current: '$current_branch')." >&2
+  exit 1
+fi
+
+echo "Fetching latest refs from origin..."
+git fetch origin
+
+local_sha=$(git rev-parse @)
+remote_sha=$(git rev-parse "origin/$default_branch")
+base_sha=$(git merge-base @ "origin/$default_branch")
+
+if [[ "$local_sha" == "$remote_sha" ]]; then
+  echo "Branch is in sync with origin/$default_branch."
+elif [[ "$local_sha" == "$base_sha" ]]; then
+  echo "Local branch is behind origin/$default_branch. Pull/rebase first." >&2
+  exit 1
+elif [[ "$remote_sha" == "$base_sha" ]]; then
+  echo "Local branch is ahead of origin/$default_branch and will be pushed."
+else
+  echo "Local and origin/$default_branch have diverged. Rebase/merge first." >&2
+  exit 1
+fi
+
+version=$(ruby -e 'require_relative "lib/after_migrate/version"; puts AfterMigrate::VERSION')
+tag="v$version"
+
+if git rev-parse "$tag" >/dev/null 2>&1 || git ls-remote --tags origin "$tag" | grep -q "$tag"; then
+  echo "Tag '$tag' already exists locally or on origin. Bump version first." >&2
+  exit 1
+fi
+
+if [[ "$skip_checks" == "false" ]]; then
+  echo "Running specs..."
+  bundle exec rspec
+
+  echo "Running RuboCop..."
+  bundle exec rubocop
+fi
+
+echo "Pushing branch '$default_branch' first..."
+git push origin "$default_branch"
+
+echo "Releasing gem with rake task..."
+bundle exec rake release
+
+echo "Release complete: $tag"

data/lib/after_migrate/adapters/postgresql.rb

@@ -9,7 +9,8 @@ module AfterMigrate
     module_function
 
     def vacuum(table_name, schema: nil, verbose: true)
-      table = ActiveRecord::Base.connection.quote_table_name("#{schema}.#{table_name}")
+      qualified = schema.present? ? "#{schema}.#{table_name}" : table_name
+      table = ActiveRecord::Base.connection.quote_table_name(qualified)
       query = <<~SQL.squish
         VACUUM (#{'VERBOSE, ' if verbose}ANALYZE, INDEX_CLEANUP ON) #{table};
       SQL
@@ -41,10 +42,11 @@ module AfterMigrate
       ActiveRecord::Base.connection.execute(query)
     end
 
-    def run_vacuum(schema:)
+    def run_vacuum(schema:, table_names: nil)
       tables_with_dead_tuples = dead_tuples(schema:).pluck('relname')
+      tables_with_dead_tuples &= Array(table_names) if table_names
       AfterMigrate.log("Vacuuming #{tables_with_dead_tuples.size} tables in schema #{schema}...")
-      tables_with_dead_tuples.each { |t| vacuum(t) }
+      tables_with_dead_tuples.each { |t| vacuum(t, schema:, verbose: AfterMigrate.configuration.verbose) }
       tables_with_dead_tuples
     end
 
@@ -63,7 +65,9 @@ module AfterMigrate
 
     def optimize_tables(table_names:, schema:, **)
       cleaned_tables = []
-      cleaned_tables = run_vacuum(schema:) if AfterMigrate.configuration.vacuum
+      cleaned_tables = run_vacuum(schema:, table_names:) if AfterMigrate.configuration.vacuum
+
+      return if AfterMigrate.configuration.analyze == 'none'
 
       tables = table_names - cleaned_tables
       run_analyze(schema:, tables:)

data/lib/after_migrate/adapters/sql.rb

@@ -3,18 +3,18 @@
 module AfterMigrate
   module Sql
     IDENT = /
-      (?:"[\w]+"|\w+)
-      (?:\.(?:"[\w]+"|\w+))*
+      (?:"\w+"|\w+)
+      (?:\.(?:"\w+"|\w+))*
     /x
 
     PATTERNS = {
-      update: /update\s+(?:only\s+)?(#{IDENT})(?!\s*\()/ix,
-      insert: /insert\s+into\s+(#{IDENT})(?!\s*\()/ix,
-      delete: /delete\s+from\s+(#{IDENT})(?!\s*\()/ix,
-      drop_table: /drop\s+table\s+(?:if\s+exists\s+)?(#{IDENT})(?!\s*\()/ix,
-      alter_table: /alter\s+table\s+(#{IDENT})(?!\s*\()/ix,
-      create_table: /create\s+table\s+(?:if\s+not\s+exists\s+)?(#{IDENT})(?!\s*\()/ix,
-      from_join: /(?:from|join)\s+(#{IDENT})(?!\s*\()/ix
+      update: /update\s+(?:only\s+)?(#{IDENT})(?!\()/ix,
+      insert: /insert\s+into\s+(#{IDENT})(?!\()/ix,
+      delete: /delete\s+from\s+(#{IDENT})(?!\()/ix,
+      drop_table: /drop\s+table\s+(?:if\s+exists\s+)?(#{IDENT})(?!\()/ix,
+      alter_table: /alter\s+table\s+(#{IDENT})(?!\()/ix,
+      create_table: /create\s+table\s+(?:if\s+not\s+exists\s+)?(#{IDENT})(?!\()/ix,
+      from_join: /(?:from|join)\s+(#{IDENT})(?!\()/ix
     }.freeze
 
     def parse_tables(sql)

data/lib/after_migrate/collector.rb

@@ -13,24 +13,15 @@ module AfterMigrate
       return unless sql.match?(/\A\s*(CREATE|ALTER|DROP|INSERT|UPDATE|DELETE|RENAME\s+TABLE|TRUNCATE)/i)
 
       table_names = parse_tables(sql)
-      schema ||= fetch_schema
-      # AfterMigrate.log("[#{schema}] Detected change from '#{sql}' to tables: #{table_names}") if table_names.present?
-      collect_tables(schema:, table_names:)
+      schema = fetch_schema
+      AfterMigrate.merge_tables(schema, table_names)
     end
 
     private
 
-    def collect_tables(schema:, table_names:)
-      return if table_names.blank?
-
-      AfterMigrate::Current.affected_tables ||= Hash.new { |h, k| h[k] = Concurrent::Set.new }
-      AfterMigrate::Current.affected_tables[schema].merge(table_names)
-    end
-
     def fetch_schema
       connection = ActiveRecord::Base.connection
-      adapter = connection.adapter_name
-      case adapter
+      case connection.adapter_name
       when 'PostgreSQL'
         quoted = connection.schema_search_path.split(',').first
         quoted&.delete('"')
@@ -39,8 +30,7 @@ module AfterMigrate
 
     def parse_tables(sql)
       connection = ActiveRecord::Base.connection
-      adapter = connection.adapter_name
-      case adapter
+      case connection.adapter_name
       when 'PostgreSQL'
         AfterMigrate::Postgresql.parse_tables(sql)
       when 'SQLite'
@@ -48,7 +38,7 @@ module AfterMigrate
       when 'Mysql2', 'Trilogy'
         AfterMigrate::Mysql.parse_tables(sql)
       else
-        AfterMigrate.log("No maintenance implemented for #{adapter}")
+        AfterMigrate.log("No maintenance implemented for #{connection.adapter_name}")
       end
     end
   end

data/lib/after_migrate/executor.rb

@@ -11,16 +11,19 @@ module AfterMigrate
 
     module_function
 
-    def call(reset: true, schema: nil)
-      # AfterMigrate.log("Executing schema: #{schema} -> #{target_tables}...")
-      return if target_tables.blank?
-      return run_optimize(schema:, tables: target_tables[schema]) if schema.present?
+    def call(schema: nil)
+      return unless AfterMigrate.configuration.vacuum || AfterMigrate.configuration.analyze != 'none'
 
-      target_tables.each do |s, tables|
-        run_optimize(schema: s, tables:)
+      tables = target_tables
+      return if tables.blank?
+
+      if schema.present?
+        run_optimize(schema:, tables: tables[schema]) if tables[schema].present?
+      else
+        tables.each { |s, t| run_optimize(schema: s, tables: t) }
       end
     ensure
-      AfterMigrate::Current.reset if reset
+      AfterMigrate.reset!
     end
 
     public :call
@@ -31,14 +34,14 @@ module AfterMigrate
       table_names = tables.to_a.sort
       return if table_names.empty?
 
-      AfterMigrate.log("Migration touched #{table_names.size} table(s): #{table_names.join(', ')}")
+      message = "Migration touched #{table_names.size} table(s) in schema #{schema.inspect}: #{table_names.join(', ')}"
+      AfterMigrate.log(message)
       optimize_tables(schema:, table_names:)
     end
 
     def optimize_tables(schema:, table_names:)
       connection = ActiveRecord::Base.connection
-      adapter = connection.adapter_name
-      case adapter
+      case connection.adapter_name
       when 'PostgreSQL'
         AfterMigrate::Postgresql.optimize_tables(schema:, table_names:, connection:)
       when 'SQLite'
@@ -46,27 +49,25 @@ module AfterMigrate
       when 'Mysql2', 'Trilogy'
         AfterMigrate::Mysql.optimize_tables(schema:, table_names:, connection:)
       else
-        AfterMigrate.log("No maintenance implemented for #{adapter}")
+        AfterMigrate.log("No maintenance implemented for #{connection.adapter_name}")
       end
     end
 
     def target_tables
       case AfterMigrate.configuration.analyze
       when 'all_tables'
-        AfterMigrate::Current.affected_tables.each_value do |schema|
-          all_tables(schema:)
+        AfterMigrate.affected_tables.keys.each_with_object({}) do |schema, hash|
+          hash[schema] = all_tables(schema:)
         end
-      when 'only_affected_tables'
-        AfterMigrate::Current.affected_tables
       else
-        []
+        # 'only_affected_tables' or 'none' — vacuum still needs the affected list
+        AfterMigrate.affected_tables
       end
     end
 
     def all_tables(schema:)
       connection = ActiveRecord::Base.connection
-      adapter = connection.adapter_name
-      case adapter
+      case connection.adapter_name
       when 'PostgreSQL'
         AfterMigrate::Postgresql.all_tables(schema:)
       when 'SQLite'

data/lib/after_migrate/railtie.rb

@@ -12,6 +12,8 @@ module AfterMigrate
         AfterMigrate::Collector.call(*args)
       end
 
+      # Unsubscribe when the app starts serving requests so normal web traffic
+      # is never collected.
       app.executor.to_run { ActiveSupport::Notifications.unsubscribe(subscription) }
     end
 
@@ -24,8 +26,16 @@ module AfterMigrate
         Rake::Task[task_name].enhance do
           next unless AfterMigrate.configuration.enabled
           next unless AfterMigrate.configuration.rake_tasks_enhanced
+          next if AfterMigrate.configuration.defer
 
-          AfterMigrate::Executor.call(reset: true)
+          AfterMigrate.run!
+        end
+      end
+
+      namespace :after_migrate do
+        desc 'Run database maintenance (ANALYZE/VACUUM) on all tables collected across migrations'
+        task run: :environment do
+          AfterMigrate.run!
         end
       end
     end

data/lib/after_migrate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AfterMigrate
-  VERSION = '0.1.1'
+  VERSION = '0.2.1'
 end

data/lib/after_migrate.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
 require 'after_migrate/version'
-require 'after_migrate/current'
 require 'after_migrate/collector'
 require 'after_migrate/executor'
 require 'after_migrate/railtie'
 
 module AfterMigrate
   class Configuration
-    attr_accessor :enabled, :verbose, :vacuum, :analyze, :rake_tasks_enhanced
+    attr_accessor :enabled, :verbose, :vacuum, :analyze, :rake_tasks_enhanced, :defer
 
     def initialize
       @enabled = true
@@ -16,6 +15,7 @@ module AfterMigrate
       @vacuum = true
       @analyze = 'only_affected_tables'
       @rake_tasks_enhanced = true
+      @defer = true
     end
   end
 
@@ -31,5 +31,29 @@ module AfterMigrate
     def log(msg)
       warn "[after_migrate] #{msg}" if AfterMigrate.configuration.verbose
     end
+
+    # Persistent cross-migration store: schema_name => Concurrent::Set<table_name>
+    def affected_tables
+      @affected_tables ||= Concurrent::Map.new
+    end
+
+    def merge_tables(schema, table_names)
+      return if table_names.blank?
+
+      set = affected_tables.compute_if_absent(schema) { Concurrent::Set.new }
+      set.merge(table_names)
+    end
+
+    # Trigger database maintenance on all collected tables, then clear the store.
+    # In multi-tenant setups call this once after all tenant migrations complete.
+    def run!(schema: nil)
+      return unless configuration.enabled
+
+      Executor.call(schema:)
+    end
+
+    def reset!
+      @affected_tables = nil
+    end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: after_migrate
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Nikolay Moskvin
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-11 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_query
@@ -54,11 +53,13 @@ files:
 - ".ruby-version"
 - ".travis.yml"
 - CHANGELOG.md
+- CLAUDE.md
 - Gemfile
 - README.md
 - Rakefile
 - after_migrate.gemspec
 - bin/console
+- bin/release
 - bin/setup
 - lib/after_migrate.rb
 - lib/after_migrate/adapters/mysql.rb
@@ -66,7 +67,6 @@ files:
 - lib/after_migrate/adapters/sql.rb
 - lib/after_migrate/adapters/sqlite.rb
 - lib/after_migrate/collector.rb
-- lib/after_migrate/current.rb
 - lib/after_migrate/executor.rb
 - lib/after_migrate/railtie.rb
 - lib/after_migrate/version.rb
@@ -79,7 +79,6 @@ metadata:
   source_code_uri: https://github.com/moskvin/after_migrate
   changelog_uri: https://github.com/moskvin/after_migrate/blob/master/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -94,8 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Automatically ANALYZE and VACUUM tables touched during Rails migrations.
 test_files: []

data/lib/after_migrate/current.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/current_attributes'
-
-module AfterMigrate
-  class Current < ActiveSupport::CurrentAttributes
-    attribute :affected_tables
-
-    resets do
-      self.affected_tables = Hash.new { |h, k| h[k] = Concurrent::Set.new }
-    end
-  end
-end