fixture_kit 0.14.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ec46a033864696a48fe4a196744b61dd142aeabee84a68f65554ccf698d4e72
-  data.tar.gz: 5e41645bf7246d12f8a0bbecb4bbad7bcb6f1f2dddab685fc6c32b459c2a3550
+  metadata.gz: ad80802447ed709427be32a3e090483bb304c97fbd6dfe66f4964cf6a2d2d5bc
+  data.tar.gz: 7d6f2e056126234ff6fab78be3b16c77d3346432a7f3fc3bb1ae2cc1606d7f29
 SHA512:
-  metadata.gz: fd821fd991c0ded4d4d10f963ece4cde8740c55c88fce238cf0033adbb791e2e64b50b3257c82a6fecd93e8810cd068e49329361b26661dd4072c1287c618ae3
-  data.tar.gz: 416bed6e4889c63a5a860c55b45e3f525499682cd5367e712b365555361fd36bd561c3e0cd02259d32f969c9877a50d0f01c570f0159af68a01334f526968f2d
+  metadata.gz: a4750ef54340da7fa136af3c046297ecd44a0d9fa96386e9a37bbe070cc5a8746c08f8bfce63815b5618c5ee7412a649f689ad884f0900ad9deb404579437688
+  data.tar.gz: 4e65d6fc64f2b5bb051667ed4e71d8bd6e8d1cdb951d1cecf45a15f083561f7cad749efba1d00e88002912611dcff197bdf78465c48d6e51838b434e197c373b

data/lib/fixture_kit/cache.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/array/wrap"
-
 module FixtureKit
   class Cache
     ANONYMOUS_DIRECTORY = "_anonymous"
 
     include ConfigurationHelper
 
-    attr_reader :fixture, :data
+    attr_reader :fixture, :content
 
     def initialize(fixture)
       @fixture = fixture
@@ -30,11 +28,11 @@ module FixtureKit
     end
 
     def exists?
-      data || file_cache.exists?
+      content || file_cache.exists?
     end
 
     def clear_memory
-      @data = nil
+      @content = nil
     end
 
     def load
@@ -42,88 +40,47 @@ module FixtureKit
         raise FixtureKit::CacheMissingError, "Cache does not exist for fixture '#{fixture.identifier}'"
       end
 
-      @data ||= file_cache.read
-      statements_by_connection(data.records).each do |connection, statements|
-        connection.disable_referential_integrity do
-          # execute_batch is private in current supported Rails versions.
-          # This should be revisited when Rails 8.2 makes it public.
-          connection.__send__(:execute_batch, statements, "FixtureKit Load")
-        end
+      @content ||= file_cache.read
+
+      FixtureKit.runner.coders.each do |coder|
+        coder.mount(content.data_for(coder.class))
       end
 
-      Repository.new(data.exposed)
+      Repository.new(content.exposed)
     end
 
     def save
       FixtureKit.runner.adapter.execute do |context|
-        captured_models = SqlSubscriber.capture do
-          fixture.definition.evaluate(context, parent: fixture.parent&.mount)
-        end
-
-        if fixture.parent
-          captured_models.concat(fixture.parent.cache.data.records.keys)
-        end
-
-        @data = MemoryCache.new(
-          records: generate_statements(captured_models),
+        @content = MemoryCache.new(
+          data: evaluate(FixtureKit.runner.coders, context),
           exposed: file_cache.serialize_exposed(fixture.definition.exposed)
         )
       end
 
-      file_cache.write(data)
+      file_cache.write(content)
     end
 
     private
 
-    def file_cache
-      @file_cache ||= FileCache.new(
-        File.join(configuration.cache_path, "#{identifier}.json")
-      )
-    end
+    def evaluate(coders, context, data = {}, &block)
+      if coders.empty?
+        fixture.definition.evaluate(context, parent: fixture.parent&.mount)
+      else
+        coder, *remaining_coders = coders
 
-    def generate_statements(models)
-      models.uniq.each_with_object({}) do |model, statements|
-        columns = model.column_names
-
-        rows = []
-        model.unscoped.order(:id).find_each do |record|
-          row_values = columns.map do |col|
-            value = record.read_attribute_before_type_cast(col)
-            model.connection.quote(value)
-          end
-          rows << "(#{row_values.join(", ")})"
+        parent_data = fixture.parent ? fixture.parent.cache.content.data_for(coder.class) : nil
+        data[coder.class] = coder.generate(parent_data: parent_data) do
+          evaluate(remaining_coders, context, data, &block)
         end
-
-        sql = rows.empty? ? nil : build_insert_sql(model.table_name, columns, rows, model.connection)
-        statements[model] = sql
       end
-    end
-
-    def build_delete_sql(model)
-      "DELETE FROM #{model.quoted_table_name}"
-    end
-
-    def build_insert_sql(table_name, columns, rows, connection)
-      quoted_table = connection.quote_table_name(table_name)
-      quoted_columns = columns.map { |c| connection.quote_column_name(c) }
 
-      "INSERT INTO #{quoted_table} (#{quoted_columns.join(", ")}) VALUES #{rows.join(", ")}"
+      data
     end
 
-    def statements_by_connection(records)
-      deleted_tables = Set.new
-
-      records.each_with_object({}) do |(model, sql), grouped|
-        connection = model.connection
-        grouped[connection] ||= []
-
-        table_key = [connection, model.table_name]
-        if deleted_tables.add?(table_key)
-          grouped[connection] << build_delete_sql(model)
-        end
-
-        grouped[connection] << sql if sql
-      end
+    def file_cache
+      @file_cache ||= FileCache.new(
+        File.join(configuration.cache_path, "#{identifier}.json")
+      )
     end
   end
 end

data/lib/fixture_kit/coder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module FixtureKit
+  class Coder
+    def generate(parent_data: nil, &block)
+      raise NotImplementedError, "#{self.class} must implement #generate"
+    end
+
+    def mount(data)
+      raise NotImplementedError, "#{self.class} must implement #mount"
+    end
+
+    def encode(data)
+      data
+    end
+
+    def decode(data)
+      data
+    end
+  end
+end

data/lib/fixture_kit/coders/active_record_coder.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+require "active_support/inflector"
+
+module FixtureKit
+  class ActiveRecordCoder < FixtureKit::Coder
+    EVENT = "sql.active_record"
+    NAME_PATTERN = /\A(?<model_name>.+?) (?:(?:Bulk )?(?:Insert|Upsert)|Create|Destroy|(?:Update|Delete)(?: All)?)\z/
+
+    def generate(parent_data: nil, &block)
+      captured_models = Set.new
+      subscriber = lambda do |_event_name, _start, _finish, _id, payload|
+        name = payload[:name].to_s
+        model_name = name[NAME_PATTERN, :model_name]
+        next unless model_name
+
+        klass = ActiveSupport::Inflector.safe_constantize(model_name)
+        next unless klass.is_a?(Class) && klass < ActiveRecord::Base
+
+        captured_models.add(klass)
+      end
+
+      ActiveSupport::Notifications.subscribed(subscriber, EVENT, monotonic: true, &block)
+
+      captured_models.map! { |model| base_table_model(model) }
+      captured_models.merge(parent_data.keys) if parent_data
+
+      generate_statements(captured_models)
+    end
+
+    def mount(data)
+      models_by_pool(data).each do |pool, models|
+        pool.with_connection do |connection|
+          statements = models.flat_map do |model|
+            [build_delete_sql(connection, model.table_name), data[model]].compact
+          end
+
+          connection.disable_referential_integrity do
+            # execute_batch is private in current supported Rails versions.
+            # This should be revisited when Rails 8.2 makes it public.
+            connection.__send__(:execute_batch, statements, "FixtureKit Insert")
+          end
+
+          verify_foreign_keys!(connection)
+
+          # Replayed INSERTs use explicit PKs, which Postgres sequences do not
+          # observe. Re-sync the sequence so subsequent Model.create calls don't
+          # collide with an id we just inserted. No-op on adapters whose PK
+          # generators advance from explicit-id INSERTs (MySQL, SQLite).
+          reset_primary_key_sequences(connection, models.map(&:table_name))
+        end
+      end
+    end
+
+    def decode(data)
+      data.transform_keys do |model_name|
+        ActiveSupport::Inflector.constantize(model_name)
+      end
+    end
+
+    private
+
+    def base_table_model(model)
+      model = model.superclass until model.superclass == ActiveRecord::Base || model.superclass.abstract_class?
+      model
+    end
+
+    def generate_statements(models)
+      models.each_with_object({}) do |model, statements|
+        columns = insertable_columns(model)
+        column_names = columns.map(&:name)
+
+        rows = []
+        model.unscoped.order(:id).find_each do |record|
+          row_values = column_names.map do |col|
+            value = record.read_attribute_before_type_cast(col)
+            model.connection.quote(value)
+          end
+          rows << "(#{row_values.join(", ")})"
+        end
+
+        sql = rows.empty? ? nil : build_insert_sql(model.table_name, column_names, rows, model.connection)
+        statements[model] = sql
+      end
+    end
+
+    def insertable_columns(model)
+      supports_virtual = model.connection.supports_virtual_columns?
+      model.columns.reject { |c| supports_virtual && c.virtual? }
+    end
+
+    def build_delete_sql(connection, table_name)
+      "DELETE FROM #{connection.quote_table_name(table_name)}"
+    end
+
+    def build_insert_sql(table_name, columns, rows, connection)
+      quoted_table = connection.quote_table_name(table_name)
+      quoted_columns = columns.map { |c| connection.quote_column_name(c) }
+
+      "INSERT INTO #{quoted_table} (#{quoted_columns.join(", ")}) VALUES #{rows.join(", ")}"
+    end
+
+    def verify_foreign_keys!(connection)
+      return unless ActiveRecord.verify_foreign_keys_for_fixtures
+
+      begin
+        connection.check_all_foreign_keys_valid!
+      rescue ActiveRecord::StatementInvalid => e
+        raise FixtureKit::Error,
+          "Foreign key violations found in cached fixture data. The cache may be " \
+          "stale relative to your current schema or fixture definitions. " \
+          "Original error:\n\n#{e.message}"
+      end
+    end
+
+    def reset_primary_key_sequences(connection, tables)
+      # Rails main (>= 8.2) batches the reset in one round-trip per connection.
+      # Older versions fall back to one query per table.
+      if connection.respond_to?(:reset_column_sequences!)
+        connection.reset_column_sequences!(tables.map { |t| [t] })
+      elsif connection.respond_to?(:reset_pk_sequence!)
+        tables.each { |t| connection.reset_pk_sequence!(t) }
+      end
+    end
+
+    def models_by_pool(data)
+      seen = Set.new
+
+      data.each_with_object({}) do |(model, _), grouped|
+        pool = model.connection_pool
+        next unless seen.add?([pool, model.table_name])
+
+        grouped[pool] ||= []
+        grouped[pool] << model
+      end
+    end
+  end
+end

data/lib/fixture_kit/configuration.rb

@@ -4,14 +4,19 @@ module FixtureKit
   class Configuration
     attr_accessor :fixture_path
     attr_accessor :cache_path
-    attr_reader :adapter_options, :callbacks
+    attr_reader :adapter_options, :callbacks, :coders
 
     def initialize
       @fixture_path = "fixture_kit"
       @cache_path = "tmp/cache/fixture_kit"
-      @adapter_class = FixtureKit::MinitestAdapter
+      @adapter_class = MinitestAdapter
       @adapter_options = {}
       @callbacks = Callbacks.new
+      @coders = Set.new([ActiveRecordCoder])
+    end
+
+    def register(coder)
+      @coders.add(coder)
     end
 
     def adapter(adapter_class = nil, **options)

data/lib/fixture_kit/file_cache.rb

@@ -17,12 +17,14 @@ module FixtureKit
     end
 
     def read
-      file_data = JSON.parse(File.read(path))
-      records = file_data.fetch("records").transform_keys do |model_name|
-        ActiveSupport::Inflector.constantize(model_name)
+      content = JSON.parse(File.read(path))
+
+      data = content.fetch("data").to_h do |coder_name, coder_data|
+        coder = coder_for(coder_name)
+        [coder.class, coder.decode(coder_data)]
       end
 
-      exposed = file_data.fetch("exposed").each_with_object({}) do |(name, value), hash|
+      exposed = content.fetch("exposed").each_with_object({}) do |(name, value), hash|
         if value.is_a?(Array)
           hash[name.to_sym] = value.map { |r| { ActiveSupport::Inflector.constantize(r.keys.first) => r.values.first } }
         else
@@ -30,12 +32,20 @@ module FixtureKit
         end
       end
 
-      MemoryCache.new(records: records, exposed: exposed)
+      MemoryCache.new(data: data, exposed: exposed)
     end
 
     def write(data)
+      content = {
+        data: data.data.to_h do |coder_class, coder_data|
+          coder = coder_for(coder_class.name)
+          [coder.class, coder.encode(coder_data)]
+        end,
+        exposed: data.exposed,
+      }
+
       FileUtils.mkdir_p(File.dirname(path))
-      File.write(path, JSON.pretty_generate(data.to_h))
+      File.write(path, JSON.pretty_generate(content))
     end
 
     def serialize_exposed(exposed)
@@ -47,5 +57,12 @@ module FixtureKit
         end
       end
     end
+
+    private
+
+    def coder_for(class_name)
+      @coder_for ||= FixtureKit.runner.coders.index_by { |c| c.class.name }
+      @coder_for.fetch(class_name)
+    end
   end
 end

data/lib/fixture_kit/memory_cache.rb

@@ -2,16 +2,16 @@
 
 module FixtureKit
   class MemoryCache
-    attr_reader :records, :exposed
+    attr_reader :data, :exposed
 
-    def initialize(records:, exposed:)
-      @records = records
+    def initialize(data:, exposed:)
+      @data = data
       @exposed = exposed
       freeze
     end
 
-    def to_h
-      { records: records, exposed: exposed }
+    def data_for(coder_class)
+      data.fetch(coder_class)
     end
   end
 end

data/lib/fixture_kit/runner.rb

@@ -30,6 +30,10 @@ module FixtureKit
       @adapter ||= configuration.adapter.new(configuration.adapter_options)
     end
 
+    def coders
+      @coders ||= configuration.coders.map(&:new)
+    end
+
     def started?
       @started
     end

data/lib/fixture_kit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FixtureKit
-  VERSION = "0.14.0"
+  VERSION = "0.16.0"
 end

data/lib/fixture_kit.rb

@@ -20,7 +20,6 @@ module FixtureKit
   autoload :Definition, File.expand_path("fixture_kit/definition", __dir__)
   autoload :Registry, File.expand_path("fixture_kit/registry", __dir__)
   autoload :Repository, File.expand_path("fixture_kit/repository", __dir__)
-  autoload :SqlSubscriber, File.expand_path("fixture_kit/sql_subscriber", __dir__)
   autoload :Cache, File.expand_path("fixture_kit/cache", __dir__)
   autoload :FileCache, File.expand_path("fixture_kit/file_cache", __dir__)
   autoload :MemoryCache, File.expand_path("fixture_kit/memory_cache", __dir__)
@@ -28,6 +27,8 @@ module FixtureKit
   autoload :Adapter, File.expand_path("fixture_kit/adapter", __dir__)
   autoload :MinitestAdapter, File.expand_path("fixture_kit/adapters/minitest_adapter", __dir__)
   autoload :RSpecAdapter, File.expand_path("fixture_kit/adapters/rspec_adapter", __dir__)
+  autoload :Coder, File.expand_path("fixture_kit/coder", __dir__)
+  autoload :ActiveRecordCoder, File.expand_path("fixture_kit/coders/active_record_coder", __dir__)
 
   extend Singleton
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixture_kit
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Ngan Pham
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-07 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -160,6 +160,8 @@ files:
 - lib/fixture_kit/analyzer/text_formatter.rb
 - lib/fixture_kit/cache.rb
 - lib/fixture_kit/callbacks.rb
+- lib/fixture_kit/coder.rb
+- lib/fixture_kit/coders/active_record_coder.rb
 - lib/fixture_kit/configuration.rb
 - lib/fixture_kit/configuration_helper.rb
 - lib/fixture_kit/definition.rb
@@ -173,7 +175,6 @@ files:
 - lib/fixture_kit/rspec.rb
 - lib/fixture_kit/runner.rb
 - lib/fixture_kit/singleton.rb
-- lib/fixture_kit/sql_subscriber.rb
 - lib/fixture_kit/version.rb
 homepage: https://github.com/Gusto/fixture_kit
 licenses:

data/lib/fixture_kit/sql_subscriber.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/notifications"
-require "active_support/inflector"
-
-module FixtureKit
-  class SqlSubscriber
-    EVENT = "sql.active_record"
-    NAME_PATTERN = /\A(?<model_name>.+?) (?:(?:Bulk )?(?:Insert|Upsert)|Create|Destroy|(?:Update|Delete)(?: All)?)\z/
-
-    def self.capture(&block)
-      models = Set.new
-      subscriber = lambda do |_event_name, _start, _finish, _id, payload|
-        name = payload[:name].to_s
-        model_name = name[NAME_PATTERN, :model_name]
-        next unless model_name
-
-        models.add(ActiveSupport::Inflector.constantize(model_name))
-      end
-
-      ActiveSupport::Notifications.subscribed(subscriber, EVENT, monotonic: true, &block)
-
-      models.map { |model| base_table_model(model) }.uniq
-    end
-
-    def self.base_table_model(model)
-      model = model.superclass until model.superclass == ActiveRecord::Base || model.superclass.abstract_class?
-      model
-    end
-    private_class_method :base_table_model
-  end
-end