fixture_kit 0.13.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 109e5fa3e9da5e57574f2942265e0a175d7eb7790b9958b645ac32c64384d08b
-  data.tar.gz: 8082b4b0f1d2c39353aad564ffb4c1b918308b31675f847fc2cf93a6f0020ab2
+  metadata.gz: abc9fb9ae8fd65e1d8a6e3ecc6ddb588b57c528424d521a5710998526df5a490
+  data.tar.gz: 0c706753a232664188d72ff1caf456ebb18fa38002016f4a266566cf04944820
 SHA512:
-  metadata.gz: dfb07fe354ed0a7eb8df7e52fd5807e994a7165579247ab73eebea1c30efe6d505ec7b86c6331c1144aaac652d9521e683fec5ed6a7f2c55c2b0bd83d308184b
-  data.tar.gz: a1affc9ef20e4bdf533d51614e61ec85d56fd5f429606e83fc417611023bfd2511983a814a55f06c5c3396dd4a07de956b3e123e81cca536620da61797e23ded
+  metadata.gz: 2af988212619c3a3ac196f808d53aacf77192a4039f21d70b0cc1fd3592eb171ff485e35ee4925931418850688e1c1491d84266ab35bcfa84e38d918db8bc37f
+  data.tar.gz: dcfd8912c6f5dea4a01482623a5b2f9f8f7d187e7d684ef04c2c755c830f15858307dc4917b45ecba164d48c43f24463fb0100676db89c5969a300e303cb0321

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,97 @@
+# 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
+
+        captured_models.add(ActiveSupport::Inflector.constantize(model_name))
+      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)
+      statements_by_connection(data).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
+      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 = 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(", ")})"
+        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(", ")}"
+    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
+    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/definition.rb

@@ -10,6 +10,10 @@ module FixtureKit
       @extends = extends
     end
 
+    def path
+      @definition.source_location.first
+    end
+
     def evaluate(context, parent: nil)
       context.singleton_class.prepend(mixin(parent))
       context.instance_exec(&@definition)

data/lib/fixture_kit/event.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module FixtureKit
+  class Event
+    attr_reader :fixture
+
+    def initialize(fixture)
+      @fixture = fixture
+    end
+
+    def identifier
+      fixture.cache.identifier
+    end
+
+    def path
+      fixture.definition.path
+    end
+  end
+end

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/fixture.rb

@@ -46,9 +46,10 @@ module FixtureKit
       !identifier.is_a?(String)
     end
 
-    def emit(event)
+    def emit(event_name)
+      fixture_event = Event.new(self)
       unless block_given?
-        configuration.callbacks.run(event, @cache)
+        configuration.callbacks.run(event_name, fixture_event)
         return
       end
 
@@ -56,7 +57,7 @@ module FixtureKit
       elapsed = Benchmark.realtime do
         value = yield
       end
-      configuration.callbacks.run(event, @cache, elapsed)
+      configuration.callbacks.run(event_name, fixture_event, elapsed)
       value
     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.13.0"
+  VERSION = "0.15.0"
 end

data/lib/fixture_kit.rb

@@ -15,11 +15,11 @@ module FixtureKit
   autoload :Callbacks, File.expand_path("fixture_kit/callbacks", __dir__)
   autoload :ConfigurationHelper, File.expand_path("fixture_kit/configuration_helper", __dir__)
   autoload :Singleton, File.expand_path("fixture_kit/singleton", __dir__)
+  autoload :Event, File.expand_path("fixture_kit/event", __dir__)
   autoload :Fixture, File.expand_path("fixture_kit/fixture", __dir__)
   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__)
@@ -27,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.13.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Ngan Pham
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-07 00:00:00.000000000 Z
+date: 2026-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -160,9 +160,12 @@ 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
+- lib/fixture_kit/event.rb
 - lib/fixture_kit/file_cache.rb
 - lib/fixture_kit/fixture.rb
 - lib/fixture_kit/memory_cache.rb
@@ -172,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