fixture_kit 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23151d16a20be7d13a1c4a15ce4dca10a2c742ba68a1d43af339bdad65490679
-  data.tar.gz: 1c9da63eae90bbe6843d204d138fafbf3b933f0ea4fd9f42c4108331509f472b
+  metadata.gz: c052323f7423cfeb258b137bc8372833eff2f4c8b826b3fa22b25a171b2b2c0f
+  data.tar.gz: '0728daee8814033465d2b93a67e15a00eff4abe5543967167077f81e68db7dde'
 SHA512:
-  metadata.gz: 3b75d5d28b153bb082f8097309c39c6d350633faac76e1b30e5ea7413cf3bccfa9b93a3941f6eff607306f43cd53a7bc5420fd1d331fc99c66ede324f82e3902
-  data.tar.gz: 92d48a55f2a92f4f1673a890e9bba8ce6695204b7a020e3240a9db21217747c3d0f7446297706cc634a15ea3246e29d0b0adcad870152cd449056c67b75cae45
+  metadata.gz: 82149fa2c3598b2af00b2cd9b8e3691e8694f18bdc40a0abf3a47540e7c319e0821250bec0e3dce4d8aaf692ea614a17cda09970a476503b0280c7a301b95e2f
+  data.tar.gz: f4fe1ea329c354aee57ad6f53d22682309b8db9704340f52d18c4b01b42a83a47701d36fe11e739d644e13b72d02171190a530df6847386770a5edc6b786cbf2

data/README.md

@@ -106,6 +106,22 @@ end
 
 `fixture` returns a `Repository` and exposes records as methods (for example, `fixture.owner`).
 
+You can also define fixtures anonymously inline:
+
+```ruby
+RSpec.describe Book do
+  fixture do
+    owner = User.create!(name: "Alice", email: "alice@example.com")
+    featured = Book.create!(title: "Dune", owner: owner)
+    expose(owner: owner, featured: featured)
+  end
+
+  it "uses inline fixture data" do
+    expect(fixture.featured.owner).to eq(fixture.owner)
+  end
+end
+```
+
 ### 3. Configure RSpec
 
 ```ruby
@@ -117,52 +133,85 @@ RSpec.configure do |config|
 end
 ```
 
-When you call `fixture "name"` in an example group, FixtureKit registers that fixture with its runner.
+When you call `fixture "name"` or `fixture do ... end` in an example group, FixtureKit registers that fixture with its runner.
+
+### 4. Configure Minitest
+
+```ruby
+# test/test_helper.rb
+require "fixture_kit/minitest"
+
+class ActiveSupport::TestCase
+  self.use_transactional_tests = true
+end
+```
+
+When you call `fixture "name"` or `fixture do ... end` in a test class, FixtureKit registers that fixture with its runner and mounts it during test setup.
 
 ## Configuration
 
 ```ruby
 # spec/support/fixture_kit.rb
 FixtureKit.configure do |config|
-  # Where fixture definitions live (default: spec/fixture_kit)
+  # Where fixture definitions live (default: fixture_kit).
+  # Framework entrypoints set a framework-specific default:
+  # - fixture_kit/rspec -> spec/fixture_kit
+  # - fixture_kit/minitest -> test/fixture_kit
   config.fixture_path = Rails.root.join("spec/fixture_kit").to_s
 
   # Where cache files are stored (default: tmp/cache/fixture_kit)
   config.cache_path = Rails.root.join("tmp/cache/fixture_kit").to_s
 
-  # Wrapper used to isolate generation work (default: FixtureKit::TestCase::Isolator)
-  # config.isolator = FixtureKit::TestCase::Isolator
-  # config.isolator = FixtureKit::RSpec::Isolator
+  # Wrapper used to isolate generation work (default: FixtureKit::MinitestIsolator)
+  # config.isolator = FixtureKit::MinitestIsolator
+  # config.isolator = FixtureKit::RSpecIsolator
 
-  # Optional callback, called once when a fixture cache is first generated.
-  # Receives the fixture name as a String.
-  # config.on_cache = ->(fixture_name) { puts "cached #{fixture_name}" }
+  # Optional callback, called right before a fixture cache is generated.
+  # Called on first generation and forced regeneration.
+  # Receives the fixture identifier:
+  # - named fixtures: String (e.g. "teams/basic")
+  # - anonymous fixtures: scope class
+  # config.on_cache_save = ->(identifier) { puts "cached #{identifier}" }
+
+  # Optional callback, called right before a fixture cache is mounted.
+  # Receives the same fixture identifier shape as on_cache_save.
+  # config.on_cache_mount = ->(identifier) { puts "mounted #{identifier}" }
 end
 ```
 
 Custom isolators should subclass `FixtureKit::Isolator` and implement `#run`.
 `#run` receives the generation block and should execute it in whatever lifecycle you need.
 
-By default, FixtureKit uses `FixtureKit::TestCase::Isolator`, which runs generation inside an internal `ActiveSupport::TestCase` and removes that harness case from minitest runnables.
+By default, FixtureKit uses `FixtureKit::MinitestIsolator`, which runs generation inside an internal `ActiveSupport::TestCase` and removes that harness case from minitest runnables.
 
-When using `fixture_kit/rspec`, FixtureKit sets `FixtureKit::RSpec::Isolator`. It runs generation inside an internal RSpec example, and uses a null reporter so harness runs do not count toward suite example totals.
+When using `fixture_kit/rspec`, FixtureKit sets `FixtureKit::RSpecIsolator`. It runs generation inside an internal RSpec example, and uses a null reporter so harness runs do not count toward suite example totals.
 
 ## Lifecycle
 
 Fixture generation is managed by `FixtureKit::Runner`.
 
-With `fixture_kit/rspec`:
-
-1. `fixture "name"` registers the fixture with the runner during spec file load.
-2. In `before(:suite)`, runner `start`:
+1. Calling `fixture "name"` or `fixture do ... end` registers the fixture with the runner.
+2. Runner `start`:
    - clears `cache_path` (unless preserve-cache is enabled),
    - generates caches for all already-registered fixtures.
-3. If new spec files are loaded later (for example, queue-mode CI runners), newly registered fixtures are generated immediately because the runner has already started.
-4. At example runtime, fixture mounting loads from cache.
+3. If new tests are loaded after start (for example, queue-mode CI runners), newly registered fixtures are cached immediately.
+4. At test runtime, `fixture` mounts from cache and returns a `Repository`.
+
+When runner start happens:
+
+- `fixture_kit/rspec`: in `before(:suite)`.
+- `fixture_kit/minitest`: lazily during test setup for the first test class that declares `fixture`.
+
+## Fixture Declaration Rules
+
+- Only one `fixture` declaration is allowed per test context.
+- Declaring a fixture twice in the same context raises `FixtureKit::MultipleFixtures`.
+- Child contexts/classes can declare their own fixture and override parent declarations.
+- Providing both a name and a block (or neither) raises `FixtureKit::InvalidFixtureDeclaration`.
 
 ### Preserving Cache Locally
 
-If you want to skip cache clearing at suite start (e.g., to reuse caches across test runs during local development), set the `FIXTURE_KIT_PRESERVE_CACHE` environment variable:
+If you want to skip cache clearing when the runner starts (e.g., to reuse caches across test runs during local development), set the `FIXTURE_KIT_PRESERVE_CACHE` environment variable:
 
 ```bash
 FIXTURE_KIT_PRESERVE_CACHE=1 bundle exec rspec
@@ -187,15 +236,24 @@ end
 fixture "teams/sales"
 ```
 
+## Anonymous Fixture Cache Paths
+
+Anonymous fixture caches are written under the `_anonymous/` directory inside `cache_path`.
+
+- Minitest: class name is underscored into a path.
+  - `MyFeatureTest` -> `_anonymous/my_feature_test.json`
+- RSpec: class name is underscored after removing `RSpec::ExampleGroups::`.
+  - `RSpec::ExampleGroups::Foo::WithFixtureKit::Hello` -> `_anonymous/foo/with_fixture_kit/hello.json`
+
 ## How It Works
 
-1. **Cache generation**: FixtureKit executes your definition block inside the configured isolator, subscribes to `sql.active_record` notifications to track inserted models, queries those model tables, and generates batch INSERT statements with conflict handling (`INSERT OR IGNORE` for SQLite, `ON CONFLICT DO NOTHING` for PostgreSQL, `INSERT IGNORE` for MySQL).
+1. **Cache generation**: FixtureKit executes your definition block inside the configured isolator, subscribes to `sql.active_record` notifications to track created/updated/deleted models, queries those model tables, and caches SQL statements for current table contents.
 
-2. **Mounting**: FixtureKit loads the cached JSON file and executes the raw SQL INSERT statements directly. No ORM instantiation, no callbacks.
+2. **Mounting**: FixtureKit loads the cached JSON file, clears each tracked table, and executes the raw SQL INSERT statements directly. No ORM instantiation, no callbacks.
 
 3. **Repository build**: FixtureKit resolves exposed records by model + id and returns a `Repository` for method-based access.
 
-4. **Transaction isolation**: RSpec's `use_transactional_fixtures` wraps each test in a transaction that rolls back, so data doesn't persist between tests.
+4. **Transaction isolation**: Use framework transactions (`use_transactional_fixtures` in RSpec, `use_transactional_tests` in Minitest) so test writes roll back and cached data can be reused safely between tests.
 
 ### Cache Format
 
@@ -204,8 +262,8 @@ Caches are stored as JSON files in `tmp/cache/fixture_kit/`:
 ```json
 {
   "records": {
-    "User": "INSERT OR IGNORE INTO users (id, name, email) VALUES (1, 'Alice', 'alice@example.com'), (2, 'Bob', 'bob@example.com')",
-    "Project": "INSERT OR IGNORE INTO projects (id, name, user_id) VALUES (1, 'Website', 1)"
+    "User": "INSERT INTO users (id, name, email) VALUES (1, 'Alice', 'alice@example.com'), (2, 'Bob', 'bob@example.com')",
+    "Project": "INSERT INTO projects (id, name, user_id) VALUES (1, 'Website', 1)"
   },
   "exposed": {
     "alice": { "model": "User", "id": 1 },

data/lib/fixture_kit/cache.rb

@@ -7,15 +7,30 @@ require "active_support/inflector"
 
 module FixtureKit
   class Cache
+    ANONYMOUS_DIRECTORY = "_anonymous"
+
+    include ConfigurationHelper
+
     attr_reader :fixture
 
-    def initialize(fixture, definition)
+    def initialize(fixture)
       @fixture = fixture
-      @definition = definition
     end
 
     def path
-      File.join(FixtureKit.configuration.cache_path, "#{fixture.name}.json")
+      File.join(configuration.cache_path, "#{identifier}.json")
+    end
+
+    def identifier
+      @identifier ||= begin
+        raw_identifier = fixture.identifier
+        if raw_identifier.is_a?(String)
+          raw_identifier
+        else
+          normalized_scope = raw_identifier.to_s.sub(/\ARSpec::ExampleGroups::/, "")
+          File.join(ANONYMOUS_DIRECTORY, ActiveSupport::Inflector.underscore(normalized_scope))
+        end
+      end
     end
 
     def exists?
@@ -24,27 +39,32 @@ module FixtureKit
 
     def load
       unless exists?
-        raise FixtureKit::CacheMissingError, "Cache does not exist for fixture '#{fixture.name}'"
+        raise FixtureKit::CacheMissingError, "Cache does not exist for fixture '#{fixture.identifier}'"
       end
 
       @data ||= JSON.parse(File.read(path))
       @data.fetch("records").each do |model_name, sql|
         model = ActiveSupport::Inflector.constantize(model_name)
-        model.connection.execute(sql)
+        connection = model.connection
+        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, [build_delete_sql(model), sql].compact, "FixtureKit Load")
+        end
       end
 
       build_repository(@data.fetch("exposed"))
     end
 
     def save
-      FixtureKit.configuration.isolator.run do
+      FixtureKit.runner.isolator.run do
         models = SqlSubscriber.capture do
-          @definition.evaluate
+          fixture.definition.evaluate
         end
 
         @data = {
           "records" => generate_statements(models),
-          "exposed" => build_exposed_mapping(@definition.exposed)
+          "exposed" => build_exposed_mapping(fixture.definition.exposed)
         }
       end
 
@@ -70,7 +90,7 @@ module FixtureKit
       model.find(id)
     rescue ActiveRecord::RecordNotFound
       raise FixtureKit::ExposedRecordNotFound,
-        "Could not find #{model_name} with id=#{id} for exposed record '#{exposed_name}' in fixture '#{@fixture.name}'"
+        "Could not find #{model_name} with id=#{id} for exposed record '#{exposed_name}' in fixture '#{@fixture.identifier}'"
     end
 
     def generate_statements(models)
@@ -88,37 +108,22 @@ module FixtureKit
           rows << "(#{row_values.join(", ")})"
         end
 
-        next if rows.empty?
-
-        sql = build_insert_sql(model.table_name, columns, rows, model.connection)
+        sql = rows.empty? ? nil : build_insert_sql(model.table_name, columns, rows, model.connection)
         statements_by_model[model.name] = sql
       end
 
       statements_by_model
     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) }
 
-      sql = "INSERT INTO #{quoted_table} (#{quoted_columns.join(", ")}) VALUES #{rows.join(", ")}"
-
-      add_conflict_handling(sql, connection)
-    end
-
-    def add_conflict_handling(sql, connection)
-      adapter_name = connection.adapter_name.downcase
-
-      case adapter_name
-      when /sqlite/
-        sql.sub(/\AINSERT INTO/i, "INSERT OR IGNORE INTO")
-      when /postgresql/, /postgis/
-        "#{sql} ON CONFLICT DO NOTHING"
-      when /mysql/, /trilogy/
-        sql.sub(/\AINSERT INTO/i, "INSERT IGNORE INTO")
-      else
-        sql
-      end
+      "INSERT INTO #{quoted_table} (#{quoted_columns.join(", ")}) VALUES #{rows.join(", ")}"
     end
 
     def build_exposed_mapping(exposed)

data/lib/fixture_kit/configuration.rb

@@ -5,17 +5,19 @@ module FixtureKit
     attr_writer :fixture_path
     attr_writer :cache_path
     attr_accessor :isolator
-    attr_accessor :on_cache
+    attr_accessor :on_cache_save
+    attr_accessor :on_cache_mount
 
     def initialize
-      @fixture_path = nil
+      @fixture_path = "fixture_kit"
       @cache_path = nil
-      @isolator = FixtureKit::TestCase::Isolator
-      @on_cache = nil
+      @isolator = FixtureKit::MinitestIsolator
+      @on_cache_save = nil
+      @on_cache_mount = nil
     end
 
     def fixture_path
-      @fixture_path ||= detect_fixture_path
+      @fixture_path
     end
 
     def cache_path
@@ -24,20 +26,6 @@ module FixtureKit
 
     private
 
-    def detect_fixture_path
-      if defined?(RSpec)
-        "spec/fixture_kit"
-      elsif defined?(Minitest)
-        "test/fixture_kit"
-      elsif Dir.exist?("spec")
-        "spec/fixture_kit"
-      elsif Dir.exist?("test")
-        "test/fixture_kit"
-      else
-        "spec/fixture_kit"
-      end
-    end
-
     def detect_cache_path
       "tmp/cache/fixture_kit"
     end

data/lib/fixture_kit/configuration_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module FixtureKit
+  module ConfigurationHelper
+    private
+
+    def configuration
+      FixtureKit.runner.configuration
+    end
+  end
+end

data/lib/fixture_kit/definition.rb

@@ -2,10 +2,11 @@
 
 module FixtureKit
   class Definition
-    attr_reader :exposed
+    attr_reader :exposed, :source_location
 
     def initialize(&definition)
       @definition = definition
+      @source_location = definition.source_location
       @exposed = {}
     end
 

data/lib/fixture_kit/fixture.rb

@@ -2,38 +2,30 @@
 
 module FixtureKit
   class Fixture
-    attr_reader :name, :path
+    include ConfigurationHelper
 
-    def initialize(name, path)
-      @name = name
-      @path = path
-      @cache = Cache.new(self, definition)
+    attr_reader :identifier, :definition
+
+    def initialize(identifier, definition)
+      @identifier = identifier
+      @definition = definition
+      @cache = Cache.new(self)
     end
 
     def cache(force: false)
-      already_cached = @cache.exists?
-      return if already_cached && !force
+      return if @cache.exists? && !force
 
+      configuration.on_cache_save&.call(@cache.identifier)
       @cache.save
-      FixtureKit.configuration.on_cache&.call(name) unless already_cached
     end
 
     def mount
       unless @cache.exists?
-        raise FixtureKit::CacheMissingError, "Cache does not exist for fixture '#{name}'"
+        raise FixtureKit::CacheMissingError, "Cache does not exist for fixture '#{identifier}'"
       end
 
+      configuration.on_cache_mount&.call(@cache.identifier)
       @cache.load
     end
-
-    private
-
-    def definition
-      @definition ||= begin
-        definition = eval(File.read(@path), TOPLEVEL_BINDING.dup, @path)
-        raise FixtureKit::FixtureDefinitionNotFound, "Could not find fixture definition at '#{@path}'" unless definition.is_a?(Definition)
-        definition
-      end
-    end
   end
 end

data/lib/fixture_kit/isolators/minitest_isolator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "active_support/test_case"
+require "active_record/fixtures"
+
+module FixtureKit
+  class MinitestIsolator < FixtureKit::Isolator
+    TEST_NAME = "fixture kit cache pregeneration"
+
+    def run(&block)
+      test_class = build_test_class
+      test_method = test_class.test(TEST_NAME) do
+        block.call
+        pass
+      end
+
+      result = test_class.new(test_method).run
+      return if result.passed?
+
+      raise result.failures.first.error
+    end
+
+    private
+
+    def build_test_class
+      Class.new(ActiveSupport::TestCase) do
+        ::Minitest::Runnable.runnables.delete(self)
+        include(::ActiveRecord::TestFixtures)
+      end
+    end
+  end
+end

data/lib/fixture_kit/isolators/rspec_isolator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FixtureKit
+  class RSpecIsolator < FixtureKit::Isolator
+    def run(&block)
+      previous_example = ::RSpec.current_example
+      previous_scope = ::RSpec.current_scope
+      example_group = build_example_group
+      example = example_group.example { block.call }
+      instance = example_group.new
+      succeeded =
+        begin
+          example.run(instance, ::RSpec::Core::NullReporter)
+        ensure
+          ::RSpec.current_example = previous_example
+          ::RSpec.current_scope = previous_scope
+        end
+
+      raise example.exception unless succeeded
+    end
+
+    private
+
+    def build_example_group
+      ::RSpec::Core::ExampleGroup.subclass(
+        ::RSpec::Core::ExampleGroup,
+        "FixtureKit",
+        [],
+        []
+      )
+    end
+  end
+end

data/lib/fixture_kit/minitest.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "fixture_kit"
+require "active_support/lazy_load_hooks"
+
+module FixtureKit
+  module Minitest
+    DECLARATION_CLASS_ATTRIBUTE = :fixture_kit_declaration
+
+    module ClassMethods
+      def fixture(name = nil, &definition_block)
+        self.fixture_kit_declaration = FixtureKit.runner.register(self, name, &definition_block)
+      end
+    end
+
+    module InstanceMethods
+      def fixture
+        @_fixture_kit_repository || raise("No fixture declared for this test class. Use `fixture \"name\"` in your test class.")
+      end
+    end
+
+    def self.configure!(test_case)
+      FixtureKit.runner.configuration.fixture_path = "test/fixture_kit"
+      FixtureKit.runner.configuration.isolator = FixtureKit::MinitestIsolator
+
+      test_case.class_attribute DECLARATION_CLASS_ATTRIBUTE, instance_accessor: false
+      test_case.extend ClassMethods
+      test_case.include InstanceMethods
+
+      test_case.setup do
+        declaration = self.class.fixture_kit_declaration
+        next unless declaration
+
+        FixtureKit.runner.start unless FixtureKit.runner.started?
+        @_fixture_kit_repository = declaration.mount
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_support_test_case) do
+  FixtureKit::Minitest.configure!(self)
+end

data/lib/fixture_kit/registry.rb

@@ -1,34 +1,56 @@
 # frozen_string_literal: true
 
-require "pathname"
-
 module FixtureKit
   class Registry
-    def initialize(configuration)
-      @configuration = configuration
-      @registry = {}
-    end
+    include ConfigurationHelper
 
-    def add(name)
-      return @registry[name] if @registry.key?(name)
+    def initialize
+      @declarations = {}
+      @fixtures = {}
+    end
 
-      file_path = fixture_file_path(name)
-      unless File.file?(file_path)
-        raise FixtureKit::FixtureDefinitionNotFound,
-          "Could not find fixture definition file for '#{name}' at '#{file_path}'"
+    def add(scope, name_or_block)
+      if @declarations.key?(scope)
+        raise FixtureKit::MultipleFixtures, "cannot load multiple fixtures in the same context"
       end
 
-      @registry[name] = Fixture.new(name, file_path)
+      @declarations[scope] =
+        case name_or_block
+        when String
+          fetch_named_fixture(name_or_block)
+        when Proc
+          fetch_anonymous_fixture(scope, name_or_block)
+        else
+          raise FixtureKit::InvalidFixtureDeclaration, "unsupported fixture declaration type: #{name_or_block.class}"
+        end
     end
 
     def fixtures
-      @registry.values
+      @fixtures.values
     end
 
     private
 
-    def fixture_file_path(name)
-      File.expand_path(File.join(@configuration.fixture_path, "#{name}.rb"))
+    def fetch_named_fixture(name)
+      @fixtures[name] ||= Fixture.new(name, load_named_definition(name))
+    end
+
+    def fetch_anonymous_fixture(scope, definition)
+      @fixtures[scope] ||= Fixture.new(scope, Definition.new(&definition))
+    end
+
+    def load_named_definition(name)
+      file_path = File.expand_path(File.join(configuration.fixture_path, "#{name}.rb"))
+
+      unless File.file?(file_path)
+        raise FixtureKit::FixtureDefinitionNotFound,
+          "cannot find fixture definition file for '#{name}' at '#{file_path}'"
+      end
+
+      definition = eval(File.read(file_path), TOPLEVEL_BINDING.dup, file_path)
+      return definition if definition.is_a?(Definition)
+
+      raise FixtureKit::FixtureDefinitionNotFound, "cannot find fixture definition at '#{file_path}'"
     end
   end
 end

data/lib/fixture_kit/rspec.rb

@@ -4,8 +4,6 @@ require "fixture_kit"
 
 module FixtureKit
   module RSpec
-    autoload :Isolator, File.expand_path("rspec/isolator", __dir__)
-
     DECLARATION_METADATA_KEY = :fixture_kit_declaration
 
     # Class methods (extended via config.extend)
@@ -29,8 +27,8 @@ module FixtureKit
       #       end
       #     end
       #   end
-      def fixture(name)
-        metadata[DECLARATION_METADATA_KEY] = ::RSpec.configuration.fixture_kit.register(name)
+      def fixture(name = nil, &definition_block)
+        metadata[DECLARATION_METADATA_KEY] = ::RSpec.configuration.fixture_kit.register(self, name, &definition_block)
       end
     end
 
@@ -39,13 +37,14 @@ module FixtureKit
       # Returns the Repository for the current example's fixture.
       # Access exposed records as methods: fixture.alice, fixture.posts
       def fixture
-        @_fixture_kit_fixture_set || raise("No fixture declared for this example group. Use `fixture \"name\"` in your describe/context block.")
+        @_fixture_kit_repository || raise("No fixture declared for this example group. Use `fixture \"name\"` in your describe/context block.")
       end
     end
 
     def self.configure!(config)
+      FixtureKit.runner.configuration.fixture_path = "spec/fixture_kit"
       config.add_setting(:fixture_kit, default: FixtureKit.runner)
-      FixtureKit.configuration.isolator = Isolator
+      FixtureKit.runner.configuration.isolator = FixtureKit::RSpecIsolator
 
       config.extend ClassMethods
       config.include InstanceMethods, DECLARATION_METADATA_KEY
@@ -53,7 +52,7 @@ module FixtureKit
       # Load declared fixtures at the beginning of each example.
       # Runs inside transactional fixtures and before user-defined before hooks.
       config.prepend_before(:example, DECLARATION_METADATA_KEY) do |example|
-        @_fixture_kit_fixture_set = example.metadata[DECLARATION_METADATA_KEY].mount
+        @_fixture_kit_repository = example.metadata[DECLARATION_METADATA_KEY].mount
       end
 
       config.append_before(:suite) do

data/lib/fixture_kit/runner.rb

@@ -10,12 +10,13 @@ module FixtureKit
 
     def initialize
       @configuration = Configuration.new
-      @registry = Registry.new(configuration)
+      @registry = Registry.new
+      @isolator = nil
       @started = false
     end
 
-    def register(name)
-      registry.add(name).tap do |fixture|
+    def register(scope, name = nil, &definition_block)
+      registry.add(scope, normalize_registration(name, definition_block)).tap do |fixture|
         fixture.cache if started?
       end
     end
@@ -28,6 +29,10 @@ module FixtureKit
       registry.fixtures.each(&:cache)
     end
 
+    def isolator
+      @isolator ||= configuration.isolator.new
+    end
+
     def started?
       @started
     end
@@ -41,5 +46,16 @@ module FixtureKit
     def preserve_cache?
       ENV[PRESERVE_CACHE_ENV_KEY].to_s.match?(/\A(1|true|yes)\z/i)
     end
+
+    def normalize_registration(name, definition_block)
+      if name && definition_block
+        raise FixtureKit::InvalidFixtureDeclaration, "cannot provide both fixture name and definition block"
+      end
+
+      name_or_block = name || definition_block
+      return name_or_block if name_or_block
+
+      raise FixtureKit::InvalidFixtureDeclaration, "must provide fixture name or definition block"
+    end
   end
 end

data/lib/fixture_kit/singleton.rb

@@ -7,10 +7,6 @@ module FixtureKit
       self
     end
 
-    def configuration
-      runner.configuration
-    end
-
     def runner
       @runner ||= Runner.new
     end

data/lib/fixture_kit/sql_subscriber.rb

@@ -6,18 +6,15 @@ 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|
-        sql = payload[:sql]
-        next unless sql =~ /\AINSERT INTO/i
+        name = payload[:name].to_s
+        model_name = name[NAME_PATTERN, :model_name]
+        next unless model_name
 
-        # payload[:name] is like "User Create" - extract model name
-        name = payload[:name]
-        next unless name&.end_with?(" Create")
-
-        model_name = name.sub(/ Create\z/, "")
         models.add(ActiveSupport::Inflector.constantize(model_name))
       end
 

data/lib/fixture_kit/version.rb

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

data/lib/fixture_kit.rb

@@ -2,26 +2,28 @@
 
 module FixtureKit
   class Error < StandardError; end
-  class DuplicateFixtureError < Error; end
   class DuplicateNameError < Error; end
+  class InvalidFixtureDeclaration < Error; end
+  class MultipleFixtures < Error; end
   class CacheMissingError < Error; end
-  class PregenerationError < Error; end
   class FixtureDefinitionNotFound < Error; end
   class ExposedRecordNotFound < Error; end
   class RunnerAlreadyStartedError < Error; end
 
-  autoload :VERSION,         File.expand_path("fixture_kit/version", __dir__)
-  autoload :Configuration,   File.expand_path("fixture_kit/configuration", __dir__)
-  autoload :Singleton,       File.expand_path("fixture_kit/singleton", __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 :Runner,          File.expand_path("fixture_kit/runner", __dir__)
-  autoload :Isolator,       File.expand_path("fixture_kit/isolator", __dir__)
-  autoload :TestCase,        File.expand_path("fixture_kit/test_case", __dir__)
+  autoload :VERSION,       File.expand_path("fixture_kit/version", __dir__)
+  autoload :Configuration, File.expand_path("fixture_kit/configuration", __dir__)
+  autoload :ConfigurationHelper, File.expand_path("fixture_kit/configuration_helper", __dir__)
+  autoload :Singleton,     File.expand_path("fixture_kit/singleton", __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 :Runner,        File.expand_path("fixture_kit/runner", __dir__)
+  autoload :Isolator,      File.expand_path("fixture_kit/isolator", __dir__)
+  autoload :MinitestIsolator, File.expand_path("fixture_kit/isolators/minitest_isolator", __dir__)
+  autoload :RSpecIsolator, File.expand_path("fixture_kit/isolators/rspec_isolator", __dir__)
 
   extend Singleton
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixture_kit
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Ngan Pham
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-22 00:00:00.000000000 Z
+date: 2026-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -136,18 +136,19 @@ files:
 - lib/fixture_kit.rb
 - lib/fixture_kit/cache.rb
 - lib/fixture_kit/configuration.rb
+- lib/fixture_kit/configuration_helper.rb
 - lib/fixture_kit/definition.rb
 - lib/fixture_kit/fixture.rb
 - lib/fixture_kit/isolator.rb
+- lib/fixture_kit/isolators/minitest_isolator.rb
+- lib/fixture_kit/isolators/rspec_isolator.rb
+- lib/fixture_kit/minitest.rb
 - lib/fixture_kit/registry.rb
 - lib/fixture_kit/repository.rb
 - lib/fixture_kit/rspec.rb
-- lib/fixture_kit/rspec/isolator.rb
 - lib/fixture_kit/runner.rb
 - lib/fixture_kit/singleton.rb
 - lib/fixture_kit/sql_subscriber.rb
-- lib/fixture_kit/test_case.rb
-- lib/fixture_kit/test_case/isolator.rb
 - lib/fixture_kit/version.rb
 homepage: https://github.com/Gusto/fixture_kit
 licenses:

data/lib/fixture_kit/rspec/isolator.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module FixtureKit
-  module RSpec
-    class Isolator < FixtureKit::Isolator
-      def run(&block)
-        previous_example = ::RSpec.current_example
-        previous_scope = ::RSpec.current_scope
-        example_group = build_example_group
-        example = build_example(example_group, &block)
-        instance = example_group.new(example.inspect_output)
-        succeeded =
-          begin
-            example.run(instance, ::RSpec::Core::NullReporter)
-          ensure
-            example_group.remove_example(example)
-            ::RSpec.current_example = previous_example
-            ::RSpec.current_scope = previous_scope
-          end
-
-        unless succeeded
-          raise example.exception if example.exception
-          raise FixtureKit::PregenerationError, "FixtureKit pregeneration failed"
-        end
-      end
-
-      private
-
-      def build_example(example_group, &block)
-        example_group.example(
-          "FixtureKit cache pregeneration"
-        ) { block.call }
-      end
-
-      def build_example_group
-        ::RSpec::Core::ExampleGroup.subclass(
-          ::RSpec::Core::ExampleGroup,
-          "FixtureKit::RSpec::Isolator",
-          [],
-          []
-        )
-      end
-    end
-  end
-end

data/lib/fixture_kit/test_case/isolator.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/test_case"
-require "active_record/fixtures"
-
-module FixtureKit
-  module TestCase
-    class Isolator < FixtureKit::Isolator
-      TEST_METHOD_NAME = "test_fixture_kit_cache_pregeneration"
-
-      def run(&block)
-        result = build_test_class(&block).run
-        return if result.passed?
-
-        failure = result.failures.first
-        raise failure.error if failure.respond_to?(:error)
-        raise failure if failure
-
-        raise FixtureKit::PregenerationError, "FixtureKit pregeneration failed"
-      end
-
-      private
-
-      def build_test_class(&block)
-        Class.new(ActiveSupport::TestCase) do
-          ::Minitest::Runnable.runnables.delete(self)
-          include(::ActiveRecord::TestFixtures)
-
-          define_method(TEST_METHOD_NAME) do
-            block.call
-            pass
-          end
-        end.new(TEST_METHOD_NAME)
-      end
-    end
-  end
-end

data/lib/fixture_kit/test_case.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module FixtureKit
-  module TestCase
-    autoload :Isolator, File.expand_path("test_case/isolator", __dir__)
-  end
-end