fixture_kit 0.9.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad45a151930afb73f5c8ba3f22a93536046fa783d240ea703c248e5329d6ceae
-  data.tar.gz: fdcf019b31154c187c5057df7990647e2102c173cc6310236866202d549e846c
+  metadata.gz: 6ccc3496f3e23da0877bac37e98d2fd325daf737f4d7bc2988d80156d202c248
+  data.tar.gz: 332a5f7824ec4c449ef052bf67616c71b7bca07749f69dcb9c1369afbb95f1a4
 SHA512:
-  metadata.gz: 73e72901b28d7f55c7714cbb581b3fa4703533968d23b20c6d0e010be4001a7cc39655ad56726f125d7b655a9ad94ff770735a72eef54a50041b9f21a81511fd
-  data.tar.gz: b104a22228a595e9cac03e8facb58ca9174b62d22d15cb347b4fd9ef6c5fb11de1187b3d05c1c8cd9bd71ae0b417d965e1af436a0c4af9efdd6f4f06e75649ba
+  metadata.gz: aaab87039e3f040b6b1f200a2e853e46263449f2bc900f664d167b009adffb2eccd48fc9080051b67dc6ad8c1e12f3aca4796db45ced24f63ad35f671cddb7f6
+  data.tar.gz: 55d185c158111d9a892ceb558af729f48a2708c4975e1365a411bdbbb6a6e26d776fd511bc9505dc818aa4e4747062acb5b51b514c3efe43351ff342e036a3e9

data/README.md

@@ -89,6 +89,26 @@ end
 - ActiveRecord >= 8.0
 - ActiveSupport >= 8.0
 
+## Releasing
+
+1. Bump the version in `lib/fixture_kit/version.rb`
+2. Update lockfiles:
+   ```sh
+   bundle install
+   cd spec/dummy && bundle install && cd ../..
+   bundle exec appraisal install
+   ```
+3. Commit and push to main:
+   ```sh
+   git add lib/fixture_kit/version.rb spec/dummy/Gemfile.lock gemfiles/*.gemfile.lock
+   git commit -m "Release vX.Y.Z"
+   git push
+   ```
+4. Create a GitHub release:
+   ```sh
+   gh release create vX.Y.Z --title "vX.Y.Z" --target main --generate-notes
+   ```
+
 ## License
 
 MIT. See [LICENSE](LICENSE).

data/lib/fixture_kit/analyzer/ast_factory_detector.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "prism"
+require "set"
+
+module FixtureKit
+  module Analyzer
+    class AstFactoryDetector
+      FACTORY_METHODS = %w[create build build_stubbed create_list build_list].to_set.freeze
+
+      def initialize
+        @file_cache = {}
+      end
+
+      # Returns array of factory name strings, e.g. ["company", "employee"]
+      def detect(mod, method_name)
+        meth = mod.instance_method(method_name)
+        file, line = meth.source_location
+        return [] unless file && File.exist?(file)
+
+        ast = parse_file(file)
+        block = find_block_at_line(ast, line)
+        return [] unless block
+
+        collect_factory_calls(block)
+      rescue
+        []
+      end
+
+      private
+
+      def parse_file(path)
+        @file_cache[path] ||= Prism.parse(File.read(path)).value
+      end
+
+      # Find the block node that starts at the target line.
+      def find_block_at_line(node, target_line)
+        if node.is_a?(Prism::BlockNode) && node.location.start_line == target_line
+          return node
+        end
+
+        node.child_nodes.compact.each do |child|
+          found = find_block_at_line(child, target_line)
+          return found if found
+        end
+
+        nil
+      end
+
+      # Walk an AST subtree collecting factory call argument symbols.
+      def collect_factory_calls(node)
+        results = []
+
+        if node.is_a?(Prism::CallNode) && FACTORY_METHODS.include?(node.name.to_s)
+          first_arg = node.arguments&.arguments&.first
+          results << first_arg.value if first_arg.is_a?(Prism::SymbolNode)
+        end
+
+        node.child_nodes.compact.each { |child| results.concat(collect_factory_calls(child)) }
+        results
+      end
+    end
+  end
+end

data/lib/fixture_kit/analyzer/file_result.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module FixtureKit
+  module Analyzer
+    class FileResult
+      attr_reader :file, :total_examples, :lets
+
+      def initialize(file:, total_examples:, lets:)
+        @file = file
+        @total_examples = total_examples
+        @lets = lets.sort_by { |l| -l.example_count }
+      end
+
+      def max_reuse
+        lets.first&.example_count || 0
+      end
+
+      def to_h
+        {
+          file: file,
+          total_examples: total_examples,
+          max_reuse: max_reuse,
+          lets: lets.map(&:to_h),
+        }
+      end
+    end
+  end
+end

data/lib/fixture_kit/analyzer/group_analyzer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module FixtureKit
+  module Analyzer
+    class GroupAnalyzer
+      def initialize(detector: AstFactoryDetector.new)
+        @detector = detector
+      end
+
+      # Check if a group directly defines a let with this name
+      def group_defines_let?(group, let_name)
+        own_mod = group.const_get(:LetDefinitions, false)
+        own_mod.instance_methods(false).include?(let_name.to_sym)
+      rescue NameError
+        false
+      end
+
+      # Count examples that inherit a let defined at `group`, stopping at overrides
+      def examples_using_let(group, let_name)
+        count = group.examples.count
+        group.children.each do |child|
+          next if group_defines_let?(child, let_name)
+          count += examples_using_let(child, let_name)
+        end
+        count
+      end
+
+      # Total examples in group + all descendants
+      def total_examples(group)
+        group.examples.count + group.children.sum { |c| total_examples(c) }
+      end
+
+      # Walk tree, collect factory lets
+      def analyze(group, results = [])
+        own_mod = begin
+          group.const_get(:LetDefinitions, false)
+        rescue NameError
+          nil
+        end
+
+        if own_mod
+          own_mod.instance_methods(false).each do |method_name|
+            factories = @detector.detect(own_mod, method_name)
+            next if factories.empty?
+
+            loc = own_mod.instance_method(method_name).source_location
+            example_count = examples_using_let(group, method_name.to_s)
+
+            results << LetDefinition.new(
+              name: method_name.to_s,
+              factories: factories,
+              example_count: example_count,
+              file: loc&.first,
+              line: loc&.last,
+              group_description: group.description.to_s[0, 80],
+            )
+          end
+        end
+
+        group.children.each { |child| analyze(child, results) }
+        results
+      end
+    end
+  end
+end

data/lib/fixture_kit/analyzer/let_definition.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module FixtureKit
+  module Analyzer
+    class LetDefinition
+      attr_reader :name, :factories, :example_count, :file, :line, :group_description
+
+      def initialize(name:, factories:, example_count:, file:, line:, group_description:)
+        @name = name
+        @factories = factories
+        @example_count = example_count
+        @file = file
+        @line = line
+        @group_description = group_description
+      end
+
+      def defined_at
+        "#{file}:#{line}"
+      end
+
+      def to_h
+        {
+          let_name: name,
+          factories: factories,
+          example_count: example_count,
+          defined_at: defined_at,
+          group: group_description,
+        }
+      end
+    end
+  end
+end

data/lib/fixture_kit/analyzer/runner.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "json"
+
+module FixtureKit
+  module Analyzer
+    class Runner
+      def initialize(
+        format: ENV.fetch("ANALYZER_FORMAT", "text"),
+        limit: ENV.fetch("ANALYZER_LIMIT", "50").to_i,
+        lets_per_file: ENV.fetch("ANALYZER_LETS_PER_FILE", "8").to_i,
+        min_reuse: ENV.fetch("ANALYZER_MIN_REUSE", "2").to_i,
+        output_path: ENV["ANALYZER_OUTPUT"]
+      )
+        @format = format
+        @limit = limit
+        @lets_per_file = lets_per_file
+        @min_reuse = min_reuse
+        @output_path = output_path
+      end
+
+      def run(example_groups)
+        return if example_groups.empty?
+
+        total = example_groups.length
+        $stderr.puts "[fixture_kit:analyzer] Analyzing #{total} top-level example groups..."
+
+        analyzer = GroupAnalyzer.new
+
+        by_file = Hash.new { |h, k| h[k] = {lets: [], total_examples: 0} }
+
+        example_groups.each_with_index do |group, idx|
+          file = group.metadata[:file_path] || group.metadata[:absolute_file_path] || "unknown"
+          if (idx + 1) % 500 == 0 || idx + 1 == total
+            $stderr.puts "[fixture_kit:analyzer] Processing group #{idx + 1}/#{total} (#{file})"
+          end
+          by_file[file][:total_examples] += analyzer.total_examples(group)
+          analyzer.analyze(group, by_file[file][:lets])
+        end
+
+        results = by_file.map do |file, data|
+          FileResult.new(file: file, total_examples: data[:total_examples], lets: data[:lets])
+        end.sort_by { |r| -r.max_reuse }
+
+        output(results)
+        results
+      end
+
+      # Install the at_exit hook that runs the analyzer after rspec --dry-run
+      def self.install_rspec_hook!
+        load_start = Time.now
+
+        progress_thread = Thread.new do
+          last_count = 0
+          loop do
+            sleep 5
+            current = ::RSpec.world.example_groups.length rescue 0
+            if current != last_count
+              $stderr.puts "[fixture_kit:analyzer] Loading... #{current} top-level groups found (#{(Time.now - load_start).round(1)}s)"
+              last_count = current
+            end
+          end
+        end
+        progress_thread.abort_on_exception = false
+
+        at_exit do
+          progress_thread.kill
+          next unless defined?(::RSpec) && ::RSpec.world.example_groups.any?
+
+          $stderr.puts "[fixture_kit:analyzer] Spec loading complete: #{::RSpec.world.example_groups.length} groups in #{(Time.now - load_start).round(1)}s"
+          new.run(::RSpec.world.example_groups)
+        end
+      end
+
+      private
+
+      def output(results)
+        case @format
+        when "json"
+          json = JSON.pretty_generate(results.map(&:to_h))
+          $stdout.puts json
+        else
+          TextFormatter.new(
+            limit: @limit,
+            lets_per_file: @lets_per_file,
+            min_reuse: @min_reuse,
+          ).render(results)
+        end
+
+        if @output_path
+          File.write(@output_path, JSON.pretty_generate(results.map(&:to_h)))
+          $stderr.puts "[fixture_kit:analyzer] Full JSON written to: #{@output_path}"
+        end
+      end
+    end
+  end
+end

data/lib/fixture_kit/analyzer/text_formatter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module FixtureKit
+  module Analyzer
+    class TextFormatter
+      def initialize(limit:, lets_per_file:, min_reuse:, io: $stdout)
+        @limit = limit
+        @lets_per_file = lets_per_file
+        @min_reuse = min_reuse
+        @io = io
+      end
+
+      def render(results)
+        filtered = results.select { |r| r.max_reuse >= @min_reuse }
+
+        @io.puts
+        @io.puts "=" * 110
+        @io.puts "FACTORY LET REUSE (ranked by highest single-let example count)"
+        @io.puts "=" * 110
+        @io.puts
+        @io.puts "#{results.length} spec files analyzed, #{filtered.length} with max reuse >= #{@min_reuse}"
+
+        filtered.first(@limit).each_with_index do |result, idx|
+          @io.puts
+          @io.puts "#{idx + 1}. #{result.file}"
+          @io.puts "   examples: #{result.total_examples}  |  factory lets: #{result.lets.length}  |  max reuse: #{result.max_reuse}"
+          @io.puts "   " + "-" * 95
+
+          result.lets.first(@lets_per_file).each do |l|
+            @io.puts Kernel.format("   let(:%s)  examples: %d  factories: %s",
+              l.name, l.example_count, l.factories.join(", "))
+            @io.puts "      group: #{l.group_description}"
+          end
+
+          remaining = result.lets.length - @lets_per_file
+          @io.puts "   ... +#{remaining} more" if remaining > 0
+        end
+
+        @io.puts
+      end
+    end
+  end
+end

data/lib/fixture_kit/analyzer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# FixtureKit::Analyzer — Find high-ROI FixtureKit optimization targets.
+#
+# Analyzes RSpec specs via --dry-run to find factory_bot `let` blocks
+# and rank them by how many examples each `let` is shared across.
+# The more examples share a let, the bigger the speedup from caching
+# it with FixtureKit.
+#
+# Usage:
+#   rspec --dry-run --require fixture_kit/analyzer [spec files or dirs...]
+#
+# Options (via env vars):
+#   ANALYZER_FORMAT=text|json    Output format (default: text)
+#   ANALYZER_LIMIT=N             Max files to show (default: 50)
+#   ANALYZER_LETS_PER_FILE=N     Max lets to show per file (default: 8)
+#   ANALYZER_MIN_REUSE=N         Only show files with max reuse >= N (default: 2)
+#   ANALYZER_OUTPUT=path         Write JSON to file (default: none)
+
+module FixtureKit
+  module Analyzer
+    autoload :AstFactoryDetector, File.expand_path("analyzer/ast_factory_detector", __dir__)
+    autoload :GroupAnalyzer,      File.expand_path("analyzer/group_analyzer", __dir__)
+    autoload :LetDefinition,      File.expand_path("analyzer/let_definition", __dir__)
+    autoload :FileResult,         File.expand_path("analyzer/file_result", __dir__)
+    autoload :TextFormatter,      File.expand_path("analyzer/text_formatter", __dir__)
+    autoload :Runner,             File.expand_path("analyzer/runner", __dir__)
+  end
+end
+
+# Auto-hook into RSpec when loaded via --require
+if defined?(RSpec)
+  FixtureKit::Analyzer::Runner.install_rspec_hook!
+end

data/lib/fixture_kit/cache.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
-require "json"
-require "fileutils"
 require "active_support/core_ext/array/wrap"
-require "active_support/inflector"
 
 module FixtureKit
   class Cache
@@ -11,14 +8,14 @@ module FixtureKit
 
     include ConfigurationHelper
 
-    attr_reader :fixture
+    attr_reader :fixture, :data
 
     def initialize(fixture)
       @fixture = fixture
     end
 
     def path
-      File.join(configuration.cache_path, "#{identifier}.json")
+      file_cache.path
     end
 
     def identifier
@@ -33,7 +30,11 @@ module FixtureKit
     end
 
     def exists?
-      @data || File.exist?(path)
+      data || file_cache.exists?
+    end
+
+    def clear_memory
+      @data = nil
     end
 
     def load
@@ -41,8 +42,8 @@ module FixtureKit
         raise FixtureKit::CacheMissingError, "Cache does not exist for fixture '#{fixture.identifier}'"
       end
 
-      @data ||= JSON.parse(File.read(path))
-      statements_by_connection(@data.fetch("records")).each do |connection, statements|
+      @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.
@@ -50,31 +51,38 @@ module FixtureKit
         end
       end
 
-      Repository.new(@data.fetch("exposed"))
+      Repository.new(data.exposed)
     end
 
     def save
       FixtureKit.runner.adapter.execute do |context|
-        models = SqlSubscriber.capture do
-          fixture.definition.evaluate(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 = {
-          "records" => generate_statements(models),
-          "exposed" => build_exposed_mapping(fixture.definition.exposed)
-        }
+        @data = MemoryCache.new(
+          records: generate_statements(captured_models),
+          exposed: file_cache.serialize_exposed(fixture.definition.exposed)
+        )
       end
 
-      FileUtils.mkdir_p(File.dirname(path))
-      File.write(path, JSON.pretty_generate(@data))
+      file_cache.write(data)
     end
 
     private
 
-    def generate_statements(models)
-      statements_by_model = {}
+    def file_cache
+      @file_cache ||= FileCache.new(
+        File.join(configuration.cache_path, "#{identifier}.json")
+      )
+    end
 
-      models.each do |model|
+    def generate_statements(models)
+      models.uniq.each_with_object({}) do |model, statements|
         columns = model.column_names
 
         rows = []
@@ -87,10 +95,8 @@ module FixtureKit
         end
 
         sql = rows.empty? ? nil : build_insert_sql(model.table_name, columns, rows, model.connection)
-        statements_by_model[model.name] = sql
+        statements[model] = sql
       end
-
-      statements_by_model
     end
 
     def build_delete_sql(model)
@@ -104,18 +110,10 @@ module FixtureKit
       "INSERT INTO #{quoted_table} (#{quoted_columns.join(", ")}) VALUES #{rows.join(", ")}"
     end
 
-    def build_exposed_mapping(exposed)
-      exposed.each_with_object({}) do |(name, value), hash|
-        was_array = value.is_a?(Array)
-        records = Array.wrap(value).map { |record| { "model" => record.class.name, "id" => record.id } }
-        hash[name] = was_array ? records : records.first
-      end
-    end
-
     def statements_by_connection(records)
       deleted_tables = Set.new
-      records.each_with_object({}) do |(model_name, sql), grouped|
-        model = ActiveSupport::Inflector.constantize(model_name)
+
+      records.each_with_object({}) do |(model, sql), grouped|
         connection = model.connection
         grouped[connection] ||= []
 

data/lib/fixture_kit/definition.rb

@@ -2,16 +2,16 @@
 
 module FixtureKit
   class Definition
-    attr_reader :exposed, :source_location
+    attr_reader :exposed, :extends
 
-    def initialize(&definition)
+    def initialize(extends: nil, &definition)
       @definition = definition
-      @source_location = definition.source_location
       @exposed = {}
+      @extends = extends
     end
 
-    def evaluate(context)
-      context.singleton_class.prepend(mixin)
+    def evaluate(context, parent: nil)
+      context.singleton_class.prepend(mixin(parent))
       context.instance_exec(&@definition)
     end
 
@@ -27,13 +27,17 @@ module FixtureKit
 
     private
 
-    def mixin
+    def mixin(parent)
       definition = self
 
       Module.new do
         define_method(:expose) do |**records|
           definition.expose(**records)
         end
+
+        define_method(:parent) do
+          parent
+        end
       end
     end
   end

data/lib/fixture_kit/file_cache.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "active_support/inflector"
+
+module FixtureKit
+  class FileCache
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def exists?
+      File.exist?(path)
+    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)
+      end
+
+      exposed = file_data.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
+          hash[name.to_sym] = { ActiveSupport::Inflector.constantize(value.keys.first) => value.values.first }
+        end
+      end
+
+      MemoryCache.new(records: records, exposed: exposed)
+    end
+
+    def write(data)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, JSON.pretty_generate(data.to_h))
+    end
+
+    def serialize_exposed(exposed)
+      exposed.each_with_object({}) do |(name, record), hash|
+        if record.is_a?(Array)
+          hash[name] = record.map { |record| { record.class => record.id } }
+        else
+          hash[name] = { record.class => record.id }
+        end
+      end
+    end
+  end
+end

data/lib/fixture_kit/fixture.rb

@@ -6,17 +6,23 @@ module FixtureKit
   class Fixture
     include ConfigurationHelper
 
-    attr_reader :identifier, :definition
+    attr_reader :identifier, :definition, :parent, :cache
 
     def initialize(identifier, definition)
       @identifier = identifier
       @definition = definition
       @cache = Cache.new(self)
+
+      if definition.extends
+        @parent = FixtureKit.runner.registry.add(definition.extends)
+      end
     end
 
-    def cache(force: false)
+    def generate(force: false)
       return if @cache.exists? && !force
 
+      parent&.generate
+
       emit(:cache_save)
       emit(:cache_saved) { @cache.save }
     end
@@ -30,8 +36,16 @@ module FixtureKit
       emit(:cache_mounted) { @cache.load }
     end
 
+    def finish
+      @cache.clear_memory if anonymous?
+    end
+
     private
 
+    def anonymous?
+      !identifier.is_a?(String)
+    end
+
     def emit(event)
       cache_identifier = @cache.identifier
       unless block_given?

data/lib/fixture_kit/memory_cache.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FixtureKit
+  class MemoryCache
+    attr_reader :records, :exposed
+
+    def initialize(records:, exposed:)
+      @records = records
+      @exposed = exposed
+      freeze
+    end
+
+    def to_h
+      { records: records, exposed: exposed }
+    end
+  end
+end

data/lib/fixture_kit/minitest.rb

@@ -8,8 +8,10 @@ module FixtureKit
     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)
+      def fixture(name = nil, extends: nil, &block)
+        definition = Definition.new(extends: extends, &block) if block_given?
+        declaration = FixtureKit.runner.register(name || definition, self)
+        self.fixture_kit_declaration = declaration
       end
 
       def run_suite(reporter, options = {})
@@ -17,10 +19,12 @@ module FixtureKit
         if declaration && !filter_runnable_methods(options).empty?
           runner = FixtureKit.runner
           runner.start unless runner.started?
-          declaration.cache
+          declaration.generate
         end
 
         super
+
+        declaration&.finish
       end
     end
 

data/lib/fixture_kit/registry.rb

@@ -7,22 +7,27 @@ module FixtureKit
     def initialize
       @declarations = {}
       @fixtures = {}
+      @resolving = []
     end
 
-    def add(scope, name_or_block)
-      if @declarations.key?(scope)
-        raise FixtureKit::MultipleFixtures, "cannot load multiple fixtures in the same context"
-      end
-
-      @declarations[scope] =
-        case name_or_block
+    def add(name_or_definition, scope = nil)
+      fixture =
+        case name_or_definition
         when String
-          fetch_named_fixture(name_or_block)
-        when Proc
-          fetch_anonymous_fixture(scope, name_or_block)
+          fetch_named_fixture(name_or_definition)
+        when Definition
+          raise ArgumentError, "scope is required for anonymous fixture declarations" unless scope
+          fetch_anonymous_fixture(scope, name_or_definition)
         else
-          raise FixtureKit::InvalidFixtureDeclaration, "unsupported fixture declaration type: #{name_or_block.class}"
+          raise FixtureKit::InvalidFixtureDeclaration, "unsupported fixture declaration type: #{name_or_definition.class}"
         end
+
+      if scope
+        raise FixtureKit::MultipleFixtures, "cannot load multiple fixtures in the same context" if @declarations.key?(scope)
+        @declarations[scope] = fixture
+      end
+
+      fixture
     end
 
     def fixtures
@@ -32,11 +37,23 @@ module FixtureKit
     private
 
     def fetch_named_fixture(name)
-      @fixtures[name] ||= Fixture.new(name, load_named_definition(name))
+      return @fixtures[name] if @fixtures.key?(name)
+
+      if @resolving.include?(name)
+        chain = @resolving + [name]
+        start = chain.index(name)
+        raise FixtureKit::CircularFixtureInheritance,
+          "circular fixture inheritance detected: #{chain[start..].join(" -> ")}"
+      end
+
+      @resolving.push(name)
+      @fixtures[name] = Fixture.new(name, load_named_definition(name))
+      @resolving.pop
+      @fixtures[name]
     end
 
     def fetch_anonymous_fixture(scope, definition)
-      @fixtures[scope] ||= Fixture.new(scope, Definition.new(&definition))
+      @fixtures[scope] ||= Fixture.new(scope, definition)
     end
 
     def load_named_definition(name)

data/lib/fixture_kit/repository.rb

@@ -5,7 +5,7 @@ require "active_support/inflector"
 module FixtureKit
   class Repository
     def initialize(exposed_records)
-      @records = exposed_records.transform_keys(&:to_sym)
+      @records = exposed_records
       @loaded_records = {}
       define_readers
     end
@@ -33,8 +33,7 @@ module FixtureKit
     end
 
     def load_record(record_info)
-      model = ActiveSupport::Inflector.constantize(record_info.fetch("model"))
-      model.find_by(id: record_info.fetch("id"))
+      record_info.keys.first.find_by(id: record_info.values.first)
     end
   end
 end

data/lib/fixture_kit/rspec.rb

@@ -27,12 +27,17 @@ module FixtureKit
       #       end
       #     end
       #   end
-      def fixture(name = nil, &definition_block)
-        declaration = ::RSpec.configuration.fixture_kit.register(self, name, &definition_block)
+      def fixture(name = nil, extends: nil, &block)
+        definition = Definition.new(extends: extends, &block) if block_given?
+        declaration = ::RSpec.configuration.fixture_kit.register(name || definition, self)
         metadata[DECLARATION_METADATA_KEY] = declaration
 
         prepend_before(:context) do
-          self.class.metadata[DECLARATION_METADATA_KEY].cache
+          self.class.metadata[DECLARATION_METADATA_KEY].generate
+        end
+
+        append_after(:context) do
+          self.class.metadata[DECLARATION_METADATA_KEY].finish
         end
       end
     end

data/lib/fixture_kit/runner.rb

@@ -15,8 +15,8 @@ module FixtureKit
       @started = false
     end
 
-    def register(scope, name = nil, &definition_block)
-      registry.add(scope, normalize_registration(name, definition_block))
+    def register(name_or_definition, scope)
+      registry.add(name_or_definition, scope)
     end
 
     def start
@@ -43,16 +43,5 @@ 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

@@ -11,8 +11,8 @@ module FixtureKit
       @runner ||= Runner.new
     end
 
-    def define(&block)
-      Definition.new(&block)
+    def define(extends: nil, &block)
+      Definition.new(extends: extends, &block)
     end
 
     def reset

data/lib/fixture_kit/version.rb

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

data/lib/fixture_kit.rb

@@ -8,6 +8,7 @@ module FixtureKit
   class CacheMissingError < Error; end
   class FixtureDefinitionNotFound < Error; end
   class RunnerAlreadyStartedError < Error; end
+  class CircularFixtureInheritance < Error; end
 
   autoload :VERSION, File.expand_path("fixture_kit/version", __dir__)
   autoload :Configuration, File.expand_path("fixture_kit/configuration", __dir__)
@@ -20,6 +21,8 @@ module FixtureKit
   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__)
   autoload :Runner, File.expand_path("fixture_kit/runner", __dir__)
   autoload :Adapter, File.expand_path("fixture_kit/adapter", __dir__)
   autoload :MinitestAdapter, File.expand_path("fixture_kit/adapters/minitest_adapter", __dir__)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixture_kit
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Ngan Pham
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-24 00:00:00.000000000 Z
+date: 2026-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -151,12 +151,21 @@ files:
 - lib/fixture_kit/adapter.rb
 - lib/fixture_kit/adapters/minitest_adapter.rb
 - lib/fixture_kit/adapters/rspec_adapter.rb
+- lib/fixture_kit/analyzer.rb
+- lib/fixture_kit/analyzer/ast_factory_detector.rb
+- lib/fixture_kit/analyzer/file_result.rb
+- lib/fixture_kit/analyzer/group_analyzer.rb
+- lib/fixture_kit/analyzer/let_definition.rb
+- lib/fixture_kit/analyzer/runner.rb
+- lib/fixture_kit/analyzer/text_formatter.rb
 - lib/fixture_kit/cache.rb
 - lib/fixture_kit/callbacks.rb
 - lib/fixture_kit/configuration.rb
 - lib/fixture_kit/configuration_helper.rb
 - lib/fixture_kit/definition.rb
+- lib/fixture_kit/file_cache.rb
 - lib/fixture_kit/fixture.rb
+- lib/fixture_kit/memory_cache.rb
 - lib/fixture_kit/minitest.rb
 - lib/fixture_kit/registry.rb
 - lib/fixture_kit/repository.rb