factory_hoist 0.1.0

data/lib/factory_hoist/runtime.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require "openssl"
+require_relative "database_snapshot"
+require_relative "deep_copy"
+require_relative "definition"
+require_relative "transaction"
+
+module FactoryHoist
+  module Runtime
+    THREAD_KEY = :factory_hoist_runtime
+
+    module_function
+
+    def current
+      Thread.current[THREAD_KEY] ||= Session.new
+    end
+
+    def reset!
+      Thread.current[THREAD_KEY]&.close
+    ensure
+      Thread.current[THREAD_KEY] = nil
+    end
+
+    def seed(node_path, key, index = 0)
+      input = [FactoryHoist.configuration.suite_seed, node_path, key, index].join("\0")
+      OpenSSL::Digest.digest("BLAKE2b512", input).unpack1("Q>")
+    end
+
+    class Session
+      def initialize
+        @scopes = []
+        @transaction = Transaction.new
+        @examples_since_begin = 0
+      end
+
+      def enter(group, definitions, materialize: true)
+        if @scopes.empty?
+          @transaction.begin_outer
+          @examples_since_begin = 0
+        end
+        scope = Scope.new(group, definitions, @scopes)
+        @transaction.create_savepoint(scope.savepoint)
+        @scopes << scope
+        scope.materialize! if materialize
+        @transaction.clear_written! if materialize && @transaction.owned?
+      rescue Exception # rubocop:disable Lint/RescueException
+        @scopes.pop if @scopes.last == scope
+        @transaction.rollback_savepoint(scope.savepoint) if scope
+        @transaction.rollback_outer if @scopes.empty?
+        raise
+      end
+
+      def materialize(group)
+        scope = @scopes.last
+        raise Error, "hoist scope mismatch" unless scope&.group&.equal?(group)
+
+        preserve_unmanaged_writes
+        @transaction.create_savepoint(scope.savepoint)
+        scope.materialize!
+      rescue Exception # rubocop:disable Lint/RescueException
+        @transaction.rollback_savepoint(scope.savepoint) if scope
+        scope&.values&.clear
+        raise
+      ensure
+        @transaction.clear_written! if @transaction.owned?
+      end
+
+      def leave(group)
+        scope = @scopes.last
+        return unless scope
+        raise Error, "hoist scope mismatch" unless scope.group.equal?(group)
+
+        @scopes.pop
+        @transaction.rollback_savepoint(scope.savepoint)
+        @transaction.clear_written! if @transaction.owned?
+        if @scopes.empty?
+          @transaction.rollback_outer
+          @examples_since_begin = 0
+        end
+      end
+
+      def around_example(example, local: false)
+        local_transaction = @scopes.empty? && local
+        return example.run if @scopes.empty? && !local
+
+        @transaction.begin_outer if local_transaction
+
+        preserve_unmanaged_writes
+        rebuild_if_needed
+        savepoint = "factory_hoist_example_#{example.object_id}"
+        @transaction.create_savepoint(savepoint)
+        @examples_since_begin += 1
+        before = DatabaseSnapshot.call(@scopes) if FactoryHoist.configuration.paranoid_mode
+        example.run
+        after = DatabaseSnapshot.call(@scopes) if before
+        if before && before != after
+          raise SharedDataMutationError, "paranoid_mode detected changes to hoisted database rows"
+        end
+      ensure
+        @transaction.rollback_savepoint(savepoint) if savepoint
+        @transaction.clear_written! if @transaction.owned?
+        if local_transaction
+          @transaction.rollback_outer
+          @examples_since_begin = 0
+        end
+      end
+
+      def fetch(example_instance, name, fallback, definitions)
+        FactoryHoist.stats.increment(:references)
+        state = example_instance.instance_variable_get(:@__factory_hoist_values)
+        unless state
+          state = ExampleValues.new(example_instance, @scopes, definitions)
+          example_instance.instance_variable_set(:@__factory_hoist_values, state)
+        end
+        state.fetch(name, fallback)
+      end
+
+      def close
+        @transaction.rollback_savepoints
+      ensure
+        @transaction.rollback_outer
+        @scopes.clear
+        @examples_since_begin = 0
+      end
+
+      private
+
+      def preserve_unmanaged_writes
+        return unless @transaction.owned? && @transaction.written?
+
+        # ponytail: nested hook ownership is ambiguous; defer rebuilding all active scopes unless this becomes costly.
+        @scopes.each { |scope| scope.rebuildable = false }
+        @transaction.clear_written!
+      end
+
+      def rebuild_if_needed
+        budget = FactoryHoist.configuration.subxid_budget
+        return unless @transaction.owned? && @scopes.all?(&:rebuildable) && budget.positive? && @examples_since_begin >= budget
+
+        @transaction.rollback_outer
+        @transaction.begin_outer
+        @scopes.each do |scope|
+          @transaction.create_savepoint(scope.savepoint)
+          scope.materialize!
+        end
+        @transaction.clear_written!
+        @examples_since_begin = 0
+        FactoryHoist.stats.increment(:transaction_rebuilds)
+      rescue Exception # rubocop:disable Lint/RescueException
+        @transaction.rollback_outer
+        @scopes.each { |scope| scope.values.clear }
+        raise
+      end
+    end
+
+    class Scope
+      attr_accessor :rebuildable
+      attr_reader :definitions, :group, :values
+
+      def initialize(group, definitions, ancestors)
+        @group = group
+        @definitions = definitions
+        @ancestors = ancestors.dup
+        @values = {}
+        @materializing = []
+        @rebuildable = true
+      end
+
+      def savepoint
+        @savepoint ||= "factory_hoist_group_#{group.object_id}"
+      end
+
+      def materialize!
+        @values = {}
+        context = MaterializationContext.new(@ancestors, self)
+        @definitions.each_key { |name| materialize_one(name, context) }
+      end
+
+      def materialize_one(name, context)
+        return @values.fetch(name) if @values.key?(name)
+        raise Error, "circular hoist dependency: #{(@materializing + [name]).join(' -> ')}" if @materializing.include?(name)
+
+        definition = @definitions.fetch(name)
+        @materializing << name
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @values[name] = definition.materialize(context)
+        FactoryHoist.stats.increment(:materializations)
+        FactoryHoist.stats.record_cost(
+          "#{definition.node_path} #{name}",
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        )
+        @values.fetch(name)
+      ensure
+        @materializing.pop if @materializing.last == name
+      end
+    end
+
+    class MaterializationContext
+      def initialize(ancestors, current)
+        @scopes = ancestors + [current]
+      end
+
+      def [](name)
+        __factory_hoist_fetch__(name)
+      end
+
+      def __factory_hoist_evaluate__(&block)
+        instance_exec(&block)
+      end
+
+      def method_missing(name, ...)
+        return __factory_hoist_fetch__(name) if __factory_hoist_available?(name)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        __factory_hoist_available?(name) || super
+      end
+
+      private
+
+      def __factory_hoist_available?(name)
+        @scopes.reverse_each.any? { |scope| scope.values.key?(name) || scope.definitions.key?(name) }
+      end
+
+      def __factory_hoist_fetch__(name)
+        scope = @scopes.reverse_each.find { |candidate| candidate.values.key?(name) }
+        if scope
+          definition = scope.definitions.fetch(name)
+          FactoryHoist.stats.record_reference("#{definition.node_path} #{name}")
+          return scope.values.fetch(name)
+        end
+
+        scope = @scopes.reverse_each.find { |candidate| candidate.definitions.key?(name) }
+        if scope
+          definition = scope.definitions.fetch(name)
+          FactoryHoist.stats.record_reference("#{definition.node_path} #{name}")
+          return scope.materialize_one(name, self)
+        end
+
+        raise KeyError, "unknown hoist: #{name}"
+      end
+    end
+
+    class ExampleValues
+      def initialize(example, scopes, definitions)
+        @example = example
+        @scopes = scopes.dup
+        @definitions = definitions
+        @values = copy_shared_values
+        @local = {}
+        @materializing = []
+      end
+
+      def fetch(name, fallback = nil)
+        definition = @definitions[name] || fallback
+        FactoryHoist.stats.record_reference("#{definition.node_path} #{name}") if definition
+        return @values.fetch(name) if @values.key?(name)
+        return @local.fetch(name) if @local.key?(name)
+
+        raise KeyError, "unknown hoist: #{name}" unless definition
+        if @materializing.include?(name)
+          raise Error, "circular local hoist dependency: #{(@materializing + [name]).join(' -> ')}"
+        end
+
+        FactoryHoist.stats.increment(:deoptimizations)
+        @materializing << name
+        begin
+          @local[name] = definition.materialize(ExampleMaterializationContext.new(self, @example))
+        ensure
+          @materializing.pop
+        end
+      end
+
+      def defined?(name)
+        @definitions.key?(name)
+      end
+
+      private
+
+      def copy_shared_values
+        copyable = visible_values.select do |_name, value|
+          DeepCopy.call(value)
+          true
+        rescue StandardError
+          false
+        end
+        DeepCopy.call(copyable)
+      rescue StandardError
+        {}
+      end
+
+      def visible_values
+        @scopes.each_with_object({}) { |scope, values| values.merge!(scope.values) }
+      end
+    end
+
+    class ExampleMaterializationContext
+      def initialize(values, example)
+        @values = values
+        @example = example
+      end
+
+      def [](name)
+        @values.fetch(name)
+      end
+
+      def __factory_hoist_evaluate__(&block)
+        @example.instance_exec(&block)
+      end
+
+      def method_missing(name, *args, **kwargs, &block)
+        return @values.fetch(name) if args.empty? && kwargs.empty? && @values.defined?(name)
+        return @example.__send__(name, *args, **kwargs, &block) if @example.respond_to?(name, true)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @values.defined?(name) || @example.respond_to?(name, true) || super
+      end
+    end
+  end
+end

data/lib/factory_hoist/scheduler.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module FactoryHoist
+  module Scheduler
+    extend self
+
+    def install!
+      schedules = Hash.new { |hash, group| hash[group] = {} }
+      definitions.each do |group, own_definitions|
+        schedules[group]
+        own_definitions.each_value do |definition|
+          examples = referring_examples(group, definition)
+          next if examples.empty?
+
+          target = lca(examples.map(&:example_group))
+          schedules[target][definition.name] = definition
+        end
+      end
+      schedules.each { |group, scheduled| install_hooks(group, scheduled) }
+    end
+
+    def definitions_for(group)
+      group.parent_groups.reverse_each.with_object({}) do |ancestor, available|
+        available.merge!(ancestor.instance_variable_get(:@factory_hoist_definitions) || {})
+      end
+    end
+
+    private
+
+    def definitions
+      ::RSpec.world.example_groups.flat_map(&:descendants).filter_map do |group|
+        own = group.instance_variable_get(:@factory_hoist_definitions)
+        [group, own] if own && !own.empty?
+      end
+    end
+
+    def referring_examples(declaration_group, definition)
+      return [] unless hoistable_definition?(declaration_group, definition)
+
+      declaration_group.descendant_filtered_examples.select do |example|
+        available = definitions_for(example.example_group)
+        next false unless available[definition.name].equal?(definition)
+
+        references?(example.instance_variable_get(:@example_block), definition.name) ||
+          dependent_definition_references?(example.example_group, definition.name)
+      end
+    end
+
+    def hoistable_definition?(group, definition)
+      return false unless hoistable_factory?(definition)
+      return true unless definition.block
+      return false unless defined?(RubyVM::InstructionSequence)
+
+      available = definitions_for(group).keys.map(&:to_s)
+      disassembly = RubyVM::InstructionSequence.of(definition.block).disasm
+      return false if disassembly.include?("getinstancevariable")
+
+      implicit_calls = disassembly.scan(
+        /mid:([^,\s]+), argc:\d+, [^>]*(?:FCALL|VCALL)/
+      ).flatten
+      (implicit_calls - available).empty?
+    rescue StandardError
+      false
+    end
+
+    def hoistable_factory?(definition)
+      return true if FactoryHoist.configuration.factory_adapter
+
+      factory = ::FactoryBot::Internal.factory_by_name(definition.factory).with_traits(definition.traits)
+      factory.compile
+      factory.definition.constructor.nil? && factory.definition.to_create.nil?
+    rescue KeyError
+      true
+    end
+
+    def dependent_definition_references?(group, name)
+      available = definitions_for(group)
+      directly_referenced = referenced_names(group, available)
+      directly_referenced.any? { |referenced| depends_on?(available, referenced, name, {}) }
+    end
+
+    def referenced_names(group, available)
+      group.filtered_examples.flat_map do |example|
+        available.keys.select { |name| references?(example.instance_variable_get(:@example_block), name) }
+      end.uniq
+    end
+
+    def depends_on?(available, current, target, seen)
+      return true if current == target
+      return false if seen[current]
+
+      seen[current] = true
+      definition = available[current]
+      return false unless definition&.block
+
+      available.keys.any? do |name|
+        references?(definition.block, name, symbols: true) && depends_on?(available, name, target, seen)
+      end
+    end
+
+    def references?(block, name, symbols: false)
+      # ponytail: MRI bytecode finds direct calls cheaply; unsupported/dynamic calls deopt locally.
+      return true unless defined?(RubyVM::InstructionSequence)
+
+      disassembly = RubyVM::InstructionSequence.of(block)&.disasm.to_s
+      disassembly.include?("mid:#{name}, argc:0") || (symbols && disassembly.include?(":#{name}"))
+    rescue StandardError
+      true
+    end
+
+    def lca(groups)
+      groups.first.parent_groups.find { |candidate| groups.all? { |group| group.parent_groups.include?(candidate) } }
+    end
+
+    def install_hooks(group, definitions)
+      group.prepend_before(:context) do
+        next unless self.class.equal?(group)
+
+        Runtime.current.enter(group, definitions, materialize: false)
+      end
+      group.before(:context) do
+        next unless self.class.equal?(group)
+
+        Runtime.current.materialize(group)
+      end
+      group.append_after(:context) do
+        next unless self.class.equal?(group)
+
+        Runtime.current.leave(group)
+      end
+    end
+  end
+end

data/lib/factory_hoist/stats.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module FactoryHoist
+  class Stats
+    COUNTERS = %i[deoptimizations materializations references transaction_rebuilds].freeze
+
+    def initialize
+      @mutex = Mutex.new
+      reset!
+    end
+
+    def increment(counter, amount = 1)
+      raise ArgumentError, "unknown counter: #{counter}" unless COUNTERS.include?(counter)
+
+      @mutex.synchronize { @counters[counter] += amount }
+    end
+
+    def record_cost(key, seconds)
+      @mutex.synchronize { @costs[key.to_s] += seconds }
+    end
+
+    def record_reference(key)
+      @mutex.synchronize { @references[key.to_s] += 1 }
+    end
+
+    def to_h
+      @mutex.synchronize do
+        @counters.merge(
+          degradation_rate: degradation_rate,
+          reference_counts: @references.sort.to_h,
+          materialization_costs: @costs.sort_by { |_, seconds| -seconds }.to_h
+        )
+      end
+    end
+
+    def reset!
+      @mutex.synchronize do
+        @counters = COUNTERS.to_h { |counter| [counter, 0] }
+        @costs = Hash.new(0.0)
+        @references = Hash.new(0)
+      end
+    end
+
+    private
+
+    def degradation_rate
+      return 0.0 if @counters[:references].zero?
+
+      @counters[:deoptimizations].fdiv(@counters[:references])
+    end
+  end
+end

data/lib/factory_hoist/transaction.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module FactoryHoist
+  module Runtime
+    class Transaction
+      def initialize
+        @connection = nil
+        @owned = false
+        @savepoints = []
+        @written = false
+        @write_subscriber = nil
+      end
+
+      def begin_outer
+        @connection = active_record_connection
+        return unless @connection
+
+        @owned = !@connection.transaction_open?
+        if @owned
+          @connection.begin_transaction(joinable: false)
+          @write_subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
+            @written = true if payload[:connection].equal?(@connection) && @connection.write_query?(payload[:sql])
+          end
+        end
+      end
+
+      def create_savepoint(name)
+        return if @savepoints.include?(name)
+
+        begin_outer unless usable?
+        return unless usable?
+
+        @connection.create_savepoint(name)
+        @savepoints << name
+      end
+
+      def rollback_savepoint(name)
+        return unless usable? && @savepoints.include?(name)
+
+        @connection.rollback_to_savepoint(name)
+        @connection.release_savepoint(name)
+        @savepoints.delete(name)
+      end
+
+      def rollback_savepoints
+        rollback_savepoint(@savepoints.last) while usable? && @savepoints.any?
+      end
+
+      def rollback_outer
+        @connection.rollback_transaction if usable? && @owned
+      ensure
+        ActiveSupport::Notifications.unsubscribe(@write_subscriber) if @write_subscriber
+        @write_subscriber = nil
+        @written = false
+        @savepoints.clear
+        @owned = false
+      end
+
+      def owned?
+        @owned
+      end
+
+      def written?
+        @written
+      end
+
+      def clear_written!
+        @written = false
+      end
+
+      private
+
+      def usable?
+        @connection && @connection.transaction_open?
+      rescue StandardError
+        false
+      end
+
+      def active_record_connection
+        return unless defined?(::ActiveRecord::Base)
+        pool = ::ActiveRecord::Base.connection_handler.retrieve_connection_pool(
+          ::ActiveRecord::Base.connection_specification_name
+        )
+        return unless pool
+
+        ::ActiveRecord::Base.connection
+      end
+    end
+  end
+end

data/lib/factory_hoist/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FactoryHoist
+  VERSION = "0.1.0"
+end