after_migrate 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19aeb8ce5d84227e4ea467f7e0d14ff8ccdb34f49214f9201b7550ede7ffbbf3
-  data.tar.gz: 2c52a7d680cb37bc2536be8ccd822fee3b92fc6e2b91a5587fa7da1826d14993
+  metadata.gz: b9d807edc34ee3c61bcda0ef4fd2319f80bac36c3bcd1cd1e2a46eb9f5e44f28
+  data.tar.gz: 16547159bf93c5a192a38a1e92d441bcd9690412b8d58ae163f59f8bc2da71bb
 SHA512:
-  metadata.gz: f8f671d511d7dc8cecc9a33e8bd90752cd0bb5b5ccb50a485dd7215c50ee68d76ec9ce626850d18717bb507a50e0bfe31e71425d24975607144b3749da1d9345
-  data.tar.gz: 80e42d103e33f52644366ebd660a0d5252c55934386830c68f33c9418b37ffbb92310c1c2dc2dd033d9a62204f0bd8d8c78f222852796d5838c4526ae313809e
+  metadata.gz: a7e76304080055fe4b9669d9895b9fb3709266c89e29deb2e39b3d408a29ba88ef1b99ebe951e693da446d2c97fda40ba416b71fae517234b65975e250b6635d
+  data.tar.gz: 14823ec925953300f85d28586a232111f945c2b9b8fb20bdaa4bf9d3057f8467dec2eb76defda50317a5811bbd6f7071bf71bb195f188950ab2a340030e0b2a5

data/.gitignore

@@ -11,3 +11,4 @@
 .rspec_status
 .idea/
 /Gemfile.lock
+.private/

data/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.2.3] - 2026-06-01
+
+### Added
+- Redis-backed store via `config.store = :redis` for sharing collected migration tables across processes
+- `config.redis` for passing a Redis client, connection pool, or callable client provider
+- `config.redis_key_prefix` and `config.redis_ttl` for namespacing and expiring Redis store keys
+- Redis store support for run isolation via `config.run_id`
+- Redis store specs for persistence, merging, reset behavior, connection pools, `Redis.new` fallback, and missing-client errors
+
+### Changed
+- Store cache keys now include Redis-specific configuration, so changing Redis store settings rebuilds the active store instance
+
+## [0.2.2] - 2026-05-31
+
+### Added
+- Configurable store backend via `config.store`, with `:memory` as the default and `:file` for persistence across separate migration task processes
+- `config.store_path` to control where the file-backed store writes collected table names
+- `config.run_id` to isolate persisted file-store data between independent migration runs
+- File-store locking and atomic writes to avoid corrupting persisted table data during concurrent access
+- Specs for file-store persistence, corrupt JSON handling, adapter dispatch, unsupported adapters, and deferred rake task behavior
+
+### Changed
+- `AfterMigrate.affected_tables`, `AfterMigrate.merge_tables`, and `AfterMigrate.reset!` now delegate through the configured store backend
+- Executor resets the store when maintenance is disabled or no tables are pending, but keeps collected tables when adapter optimization raises so a later run can retry
+
+## [0.2.1] - 2026-05-29
+
+### Changed
+- Refactored SQL identifier matching used by the parser without changing supported table-detection behavior
+- Split executor migration logging message construction into a local variable for clearer formatting and maintenance
+- Added RuboCop project configuration for documentation, method length, and spec block length rules
+
 ## [0.2.0] - 2026-04-28
 
 ### Added

data/CLAUDE.md

@@ -22,7 +22,7 @@ This is a Rails gem that automatically runs database maintenance (`ANALYZE`, `VA
 
 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.
+3. **`AfterMigrate.store`** (`lib/after_migrate/store.rb`) — defaults to an in-memory `Concurrent::Map` wrapped by `AfterMigrate::Stores::Memory`. `AfterMigrate.affected_tables`, `merge_tables`, and `reset!` delegate to the store. The memory store persists across multiple rake task invocations inside one Ruby process and is cleared by `AfterMigrate.run!` (or `AfterMigrate.reset!`). 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.
 

data/Gemfile

@@ -11,3 +11,4 @@ gem 'bundler', '~> 4'
 gem 'rake', '~> 13.0'
 gem 'rspec', '~> 3.0'
 gem 'rubocop', '~> 1.81'
+gem 'simplecov', group: 'test'

data/lib/after_migrate/executor.rb

@@ -12,24 +12,33 @@ module AfterMigrate
     module_function
 
     def call(schema: nil)
-      return unless AfterMigrate.configuration.vacuum || AfterMigrate.configuration.analyze != 'none'
+      return reset_store unless maintenance_enabled?
 
       tables = target_tables
-      return if tables.blank?
+      return reset_store 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.reset!
+      run_optimizations(schema:, tables:)
+      reset_store
     end
 
     public :call
 
     private
 
+    def maintenance_enabled?
+      AfterMigrate.configuration.vacuum || AfterMigrate.configuration.analyze != 'none'
+    end
+
+    def reset_store
+      AfterMigrate.reset!
+    end
+
+    def run_optimizations(schema:, tables:)
+      return run_optimize(schema:, tables: tables[schema]) if schema.present? && tables[schema].present?
+
+      tables.each { |s, t| run_optimize(schema: s, tables: t) } unless schema.present?
+    end
+
     def run_optimize(schema:, tables:)
       table_names = tables.to_a.sort
       return if table_names.empty?

data/lib/after_migrate/store.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+
+module AfterMigrate
+  module Stores
+    class Memory
+      attr_reader :affected_tables
+
+      def initialize
+        @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
+
+      def reset!
+        @affected_tables = Concurrent::Map.new
+      end
+    end
+
+    class FileStore < Memory
+      attr_reader :path, :run_id
+
+      def initialize(path:, run_id: nil)
+        super()
+        @path = path.to_s
+        @run_id = run_id.to_s.presence
+      end
+
+      def affected_tables
+        load_into_memory
+        super
+      end
+
+      def merge_tables(schema, table_names)
+        return if table_names.blank?
+
+        with_lock do
+          merge_into_memory(read_schemas)
+          merge_into_memory(schema => table_names)
+          write_schemas(memory_to_hash)
+        end
+      end
+
+      def reset!
+        super
+        with_lock { ::FileUtils.rm_f(path) }
+      end
+
+      private
+
+      def load_into_memory
+        with_lock { merge_into_memory(read_schemas) }
+      end
+
+      def merge_into_memory(schemas)
+        schemas.each do |schema, table_names|
+          set = @affected_tables.compute_if_absent(schema) { Concurrent::Set.new }
+          set.merge(table_names)
+        end
+      end
+
+      def read_schemas
+        return {} unless ::File.exist?(path)
+
+        payload = JSON.parse(::File.read(path))
+        return {} if run_id && payload['run_id'].to_s != run_id
+
+        payload.fetch('schemas', {})
+      rescue JSON::ParserError
+        {}
+      end
+
+      def write_schemas(schemas)
+        ::FileUtils.mkdir_p(::File.dirname(path))
+        temp_path = "#{path}.#{$PROCESS_ID}.tmp"
+        ::File.write(temp_path, JSON.pretty_generate({ run_id:, schemas: }))
+        ::File.rename(temp_path, path)
+      ensure
+        ::FileUtils.rm_f(temp_path) if temp_path && ::File.exist?(temp_path)
+      end
+
+      def memory_to_hash
+        @affected_tables.keys.sort.each_with_object({}) do |schema, hash|
+          hash[schema] = @affected_tables[schema].to_a.sort
+        end.sort.to_h
+      end
+
+      def with_lock
+        ::FileUtils.mkdir_p(::File.dirname(path))
+        ::File.open("#{path}.lock", ::File::RDWR | ::File::CREAT, 0o644) do |file|
+          file.flock(::File::LOCK_EX)
+          yield
+        end
+      end
+    end
+
+    class RedisStore < Memory
+      attr_reader :key_prefix, :run_id, :ttl
+
+      def initialize(redis:, key_prefix: 'after_migrate', run_id: nil, ttl: 24 * 60 * 60)
+        super()
+        @redis = redis
+        @key_prefix = key_prefix.to_s
+        @run_id = run_id.to_s.presence || 'default'
+        @ttl = ttl.to_i
+      end
+
+      def affected_tables
+        load_into_memory
+        super
+      end
+
+      def merge_tables(schema, table_names)
+        return if table_names.blank?
+
+        with_redis do |redis|
+          redis.sadd(index_key, schema)
+          redis.sadd(schema_key(schema), table_names.to_a)
+          expire_keys(redis, schema)
+        end
+        merge_into_memory(schema => table_names)
+      end
+
+      def reset!
+        super
+        with_redis do |redis|
+          schemas = redis.smembers(index_key)
+          keys = schemas.map { |schema| schema_key(schema) }
+          redis.del(*(keys + [index_key])) if keys.any?
+          redis.del(index_key) if keys.empty?
+        end
+      end
+
+      private
+
+      def load_into_memory
+        with_redis do |redis|
+          redis.smembers(index_key).each do |schema|
+            merge_into_memory(schema => redis.smembers(schema_key(schema)))
+          end
+        end
+      end
+
+      def merge_into_memory(schemas)
+        schemas.each do |schema, table_names|
+          set = @affected_tables.compute_if_absent(schema) { Concurrent::Set.new }
+          set.merge(table_names)
+        end
+      end
+
+      def index_key
+        "#{base_key}:schemas"
+      end
+
+      def schema_key(schema)
+        "#{base_key}:schema:#{schema}"
+      end
+
+      def base_key
+        "#{key_prefix}:#{run_id}"
+      end
+
+      def expire_keys(redis, schema)
+        return unless ttl.positive?
+
+        redis.expire(index_key, ttl)
+        redis.expire(schema_key(schema), ttl)
+      end
+
+      def with_redis(&block)
+        redis = resolved_redis
+        return redis.with { |connection| block.call(connection) } if redis.respond_to?(:with)
+
+        block.call(redis)
+      end
+
+      def resolved_redis
+        client = @redis.respond_to?(:call) ? @redis.call : @redis
+        return client if client
+        return Redis.new if defined?(Redis)
+
+        raise 'AfterMigrate Redis store requires config.redis or the redis gem'
+      end
+    end
+  end
+end

data/lib/after_migrate/version.rb

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

data/lib/after_migrate.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 require 'after_migrate/version'
+require 'after_migrate/store'
 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, :defer
+    attr_accessor :enabled, :verbose, :vacuum, :analyze, :rake_tasks_enhanced, :defer,
+                  :store, :store_path, :run_id, :redis, :redis_key_prefix, :redis_ttl
 
     def initialize
       @enabled = true
@@ -16,6 +18,12 @@ module AfterMigrate
       @analyze = 'only_affected_tables'
       @rake_tasks_enhanced = true
       @defer = true
+      @store = :memory
+      @store_path = 'tmp/after_migrate/affected_tables.json'
+      @run_id = nil
+      @redis = nil
+      @redis_key_prefix = 'after_migrate'
+      @redis_ttl = 24 * 60 * 60
     end
   end
 
@@ -34,14 +42,11 @@ module AfterMigrate
 
     # Persistent cross-migration store: schema_name => Concurrent::Set<table_name>
     def affected_tables
-      @affected_tables ||= Concurrent::Map.new
+      store.affected_tables
     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)
+      store.merge_tables(schema, table_names)
     end
 
     # Trigger database maintenance on all collected tables, then clear the store.
@@ -53,7 +58,45 @@ module AfterMigrate
     end
 
     def reset!
-      @affected_tables = nil
+      store.reset!
+    end
+
+    def store
+      @store = nil if @store_key != store_key
+      @store_key = store_key
+      @store ||= build_store
+    end
+
+    private
+
+    def store_key
+      [
+        configuration.store.to_s,
+        configuration.store_path.to_s,
+        configuration.run_id.to_s,
+        configuration.redis_key_prefix.to_s,
+        configuration.redis_ttl.to_s
+      ]
+    end
+
+    def build_store
+      case configuration.store.to_s
+      when 'file'
+        Stores::FileStore.new(path: configuration.store_path, run_id: configuration.run_id)
+      when 'redis'
+        redis_store
+      else
+        Stores::Memory.new
+      end
+    end
+
+    def redis_store
+      Stores::RedisStore.new(
+        redis: configuration.redis,
+        key_prefix: configuration.redis_key_prefix,
+        run_id: configuration.run_id,
+        ttl: configuration.redis_ttl
+      )
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: after_migrate
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - Nikolay Moskvin
@@ -69,6 +69,7 @@ files:
 - lib/after_migrate/collector.rb
 - lib/after_migrate/executor.rb
 - lib/after_migrate/railtie.rb
+- lib/after_migrate/store.rb
 - lib/after_migrate/version.rb
 - logo.png
 homepage: https://github.com/moskvin/after_migrate