factory_hoist 0.1.0

data/lib/factory_hoist/fast_build.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "ripper"
+require "tmpdir"
+
+module FactoryHoist
+  module FastBuild
+    FALLBACK = Object.new.freeze
+    @compiled = {}
+    @generation = 0
+    @pending = {}
+    @mutex = Mutex.new
+
+    class << self
+      def call(name, traits, overrides)
+        return FALLBACK unless traits.empty?
+
+        key = name.is_a?(Symbol) ? name : name.to_sym
+        cached = @compiled[key]
+        evaluator = cached ? cached[:evaluator] : compile(key)
+        if evaluator && !overrides.empty?
+          override_names = overrides.keys.map(&:to_sym)
+          aliases = evaluator.factory_ir[:attributes].any? do |attribute|
+            override_names.any? { |override| attribute.name != override && attribute.alias_for?(override) }
+          end
+          return FALLBACK if aliases
+        end
+        evaluator ? evaluator.new(overrides).build : FALLBACK
+      end
+
+      def compile(name)
+        factory = ::FactoryBot::Internal.factory_by_name(name)
+        cached = @compiled[name.to_sym]
+        return cached[:evaluator] if cached && cached[:factory].equal?(factory)
+
+        @mutex.synchronize do
+          cached = @compiled[name.to_sym]
+          return cached[:evaluator] if cached && cached[:factory].equal?(factory)
+
+          ir = build_ir(factory)
+          return unless ir
+
+          install_reload_hook
+          @generation += 1
+          safe_name = name.to_s.gsub(/[^a-zA-Z0-9_-]/, "_")[0, 80]
+          token = "#{safe_name}_#{Process.pid}_#{factory.object_id}_#{@generation}"
+          @pending[token] = ir
+          path = source_path(token)
+          ir[:source_path] = path
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, generated_source(token, ir))
+          require path
+          @compiled.fetch(name.to_sym).fetch(:evaluator)
+        end
+      rescue KeyError, NameError
+        nil
+      end
+
+      def install(token, &builder)
+        ir = @pending.delete(token)
+        evaluator = Class.new(Evaluator)
+        ir[:attributes].each do |attribute|
+          raw_name = :"__factory_hoist_#{attribute.name}"
+          evaluator.define_method(raw_name, &attribute.to_proc)
+        end
+        evaluator.class_eval(&builder)
+        evaluator.factory_ir = ir
+        @compiled[ir[:name]] = {
+          factory: ir[:factory], evaluator: evaluator, source_path: ir[:source_path]
+        }
+      end
+
+      def reset!
+        @mutex.synchronize do
+          @compiled.clear
+          @pending.clear
+        end
+      end
+
+      def reload!
+        @mutex.synchronize do
+          @compiled.each_value { |entry| entry[:evaluator].factory_ir.delete(:klass) }
+        end
+      end
+
+      def source_path(token)
+        File.join(Dir.tmpdir, "factory_hoist", "#{token}.rb")
+      end
+
+      def compiled_source(name)
+        @compiled.dig(name.to_sym, :source_path)
+      end
+
+      private
+
+      def install_reload_hook
+        return if @reload_hook_installed
+        return unless defined?(::ActiveSupport::Reloader)
+
+        ::ActiveSupport::Reloader.to_prepare { reload! }
+        @reload_hook_installed = true
+      end
+
+      def generated_source(token, ir)
+        assignments = ir[:assigned].map { |name| "    object.#{name} = #{name}" }.join("\n")
+        known = (ir[:assigned] | ir[:ignored]).map(&:inspect).join(", ")
+        readers = ir[:attributes].map do |attribute|
+          name = attribute.name
+          <<~RUBY
+            def #{name}
+              return @cache[:#{name}] if @cache.key?(:#{name})
+              @cache[:#{name}] = __factory_hoist_#{name}
+            end
+          RUBY
+        end.join("\n")
+        <<~RUBY
+          FactoryHoist::FastBuild.install(#{token.dump}) do
+          #{readers}
+            def build
+              object = @instance = build_class.new
+          #{assignments}
+              unless @overrides.empty?
+                @overrides.each do |name, value|
+                  object.public_send(:"\#{name}=", value) unless [#{known}].include?(name)
+                end
+              end
+              object
+            end
+          end
+        RUBY
+      end
+
+      def build_ir(factory)
+        factory.compile
+        definition = factory.definition
+        return unless definition.callbacks.empty? && definition.constructor.nil?
+
+        attributes = factory.send(:attributes).to_a
+        klass = factory.build_class
+        assigned = attributes.reject(&:ignored).map(&:name)
+        names = attributes.map(&:name)
+        reserved = Evaluator.instance_methods(true) | Evaluator.private_instance_methods(true) | [:build]
+        required_arguments = klass.instance_method(:initialize).parameters.any? do |type, _name|
+          %i[req keyreq].include?(type)
+        end
+        invalid_name = names.any? do |name|
+          !name.match?(/\A[a-z_]\w*\z/) || reserved.include?(name) || Ripper.lex(name.to_s).first[1] == :on_kw
+        end
+        return if required_arguments || !klass.name || invalid_name
+
+        {
+          name: factory.name,
+          factory: factory,
+          class_name: klass.name,
+          klass: klass,
+          attributes: attributes,
+          assigned: assigned,
+          ignored: attributes.select(&:ignored).map(&:name)
+        }
+      end
+    end
+
+    class Evaluator
+      class << self
+        attr_accessor :factory_ir
+      end
+
+      def initialize(overrides)
+        @overrides = overrides.empty? ? overrides : overrides.transform_keys(&:to_sym)
+        @cache = @overrides.empty? ? {} : @overrides.dup
+      end
+
+      attr_reader :instance
+
+      def association(name, *traits_and_overrides)
+        overrides = traits_and_overrides.last.is_a?(Hash) ? traits_and_overrides.pop.dup : {}
+        strategy = overrides.delete(:strategy)
+        strategy ||= ::FactoryBot.use_parent_strategy ? :build : :create
+        if %i[build create].include?(strategy)
+          return FactoryHoist.public_send(strategy, name, *traits_and_overrides, **overrides)
+        end
+
+        ::FactoryBot.public_send(strategy, name, *traits_and_overrides, **overrides)
+      end
+
+      def method_missing(name, ...)
+        return @instance.send(name, ...) if @instance.respond_to?(name)
+        return ::FactoryBot::SyntaxRunner.new.send(name, ...) if ::FactoryBot::SyntaxRunner.new.respond_to?(name)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @instance.respond_to?(name) || ::FactoryBot::SyntaxRunner.new.respond_to?(name) || super
+      end
+
+      private
+
+      def build_class
+        ir = self.class.factory_ir
+        return ir[:klass] if ir[:klass]
+
+        parts = ir[:class_name].split("::").reject(&:empty?)
+        return ir[:klass] = Object.const_get(parts.first, false) if parts.one?
+
+        ir[:klass] = parts.inject(Object) { |scope, constant| scope.const_get(constant, false) }
+      end
+    end
+  end
+end

data/lib/factory_hoist/minitest.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module FactoryHoist
+  module MinitestDSL
+    def hoist(name, factory = name, *traits, **attributes, &block)
+      name = name.to_sym
+      definitions = if instance_variable_defined?(:@factory_hoist_definitions)
+        @factory_hoist_definitions
+      else
+        @factory_hoist_definitions = {}
+      end
+      raise DuplicateHoistError, "hoist(:#{name}) is already declared in this class" if definitions.key?(name)
+
+      definition = Definition.new(name, factory, traits.freeze, attributes.freeze, block, to_s)
+      definitions[name] = definition
+      define_method(name) { factory_hoist_local_values.fetch(name) }
+    end
+
+    def factory_hoist_definitions
+      inherited = superclass.respond_to?(:factory_hoist_definitions) ? superclass.factory_hoist_definitions : {}
+      inherited.merge(instance_variable_get(:@factory_hoist_definitions) || {})
+    end
+  end
+
+  class MinitestValues
+    def initialize(test)
+      @test = test
+      @values = {}
+    end
+
+    def fetch(name)
+      FactoryHoist.stats.increment(:references)
+      return @values[name] if @values.key?(name)
+
+      definition = @test.class.factory_hoist_definitions.fetch(name)
+      FactoryHoist.stats.record_reference("#{definition.node_path} #{name}")
+      FactoryHoist.stats.increment(:deoptimizations)
+      @values[name] = definition.materialize(self)
+    end
+
+    alias_method :[], :fetch
+
+    def __factory_hoist_evaluate__(&block)
+      @test.instance_exec(&block)
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      if args.empty? && kwargs.empty? && @test.class.factory_hoist_definitions.key?(name)
+        return fetch(name)
+      end
+      return @test.__send__(name, *args, **kwargs, &block) if @test.respond_to?(name, true)
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @test.class.factory_hoist_definitions.key?(name) || @test.respond_to?(name, true) || super
+    end
+  end
+
+  module MinitestInstance
+    private
+
+    def factory_hoist_local_values
+      @factory_hoist_local_values ||= MinitestValues.new(self)
+    end
+  end
+
+  def self.install_minitest!
+    return unless defined?(::Minitest::Test)
+    return if ::Minitest::Test.singleton_class < MinitestDSL
+
+    ::Minitest::Test.extend(MinitestDSL)
+    ::Minitest::Test.include(MinitestInstance)
+  end
+end
+
+FactoryHoist.install_minitest!

data/lib/factory_hoist/parallel_database.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module FactoryHoist
+  module ParallelDatabase
+    module_function
+
+    def clone(source:, target:, adapter:)
+      case adapter.respond_to?(:to_sym) && adapter.to_sym
+      when :postgresql then clone_postgresql(source, target)
+      when :sqlite then clone_sqlite(source, target)
+      else raise ArgumentError, "parallel database cloning is unsupported for #{adapter}"
+      end
+    end
+
+    def clone_sqlite(source, target)
+      require "sqlite3"
+
+      created = false
+      complete = false
+      mode = File.stat(source).mode & 0o777
+      File.open(target, File::WRONLY | File::CREAT | File::EXCL, 0o600).close
+      created = true
+      source_database = SQLite3::Database.new(source, readonly: true)
+      target_database = SQLite3::Database.new(target)
+      backup = SQLite3::Backup.new(target_database, "main", source_database, "main")
+      status = backup.step(-1)
+      unless status == SQLite3::Constants::ErrorCode::DONE
+        raise Error, "SQLite backup failed with status #{status}"
+      end
+
+      File.chmod(mode, target)
+      complete = true
+      target
+    rescue Errno::EEXIST
+      raise Error, "target database already exists: #{target}"
+    ensure
+      backup&.finish
+      target_database&.close
+      source_database&.close
+      File.unlink(target) if created && !complete && File.exist?(target)
+    end
+    private_class_method :clone_sqlite
+
+    def clone_postgresql(source_url, target)
+      require "pg"
+      valid_target = target.is_a?(String) && target.bytesize <= 63 && target.match?(/\A[a-zA-Z0-9_]+\z/)
+      raise ArgumentError, "invalid target database name" unless valid_target
+
+      source_connection = PG.connect(source_url)
+      parameters = source_connection.conninfo_hash.transform_keys(&:to_sym)
+        .reject { |_key, value| value.nil? || value.empty? }
+      source = parameters[:dbname]
+      source_connection.close
+      raise ArgumentError, "source URL must include a database" unless source
+
+      admin = PG.connect(parameters.merge(dbname: "postgres"))
+      admin.exec_params("SELECT pg_advisory_lock(hashtext($1))", ["factory_hoist_database_clone"])
+      ensure_cloneable!(admin, source, target)
+      admin.exec("CREATE DATABASE #{admin.quote_ident(target)} TEMPLATE #{admin.quote_ident(source)}")
+      target
+    ensure
+      source_connection&.close unless source_connection&.finished?
+      if admin && !admin.finished?
+        begin
+          admin.exec_params("SELECT pg_advisory_unlock(hashtext($1))", ["factory_hoist_database_clone"])
+        rescue PG::Error
+          nil
+        ensure
+          admin.close
+        end
+      end
+    end
+    private_class_method :clone_postgresql
+
+    def ensure_cloneable!(connection, source, target)
+      exists = connection.exec_params("SELECT 1 FROM pg_database WHERE datname = $1", [target]).ntuples.positive?
+      raise Error, "target database already exists: #{target}" if exists
+
+      connections = connection.exec_params(
+        "SELECT count(*) FROM pg_stat_activity WHERE datname = $1",
+        [source]
+      ).getvalue(0, 0).to_i
+      raise Error, "source database has #{connections} active connection(s): #{source}" if connections.positive?
+    end
+    private_class_method :ensure_cloneable!
+  end
+end

data/lib/factory_hoist/pcg32.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module FactoryHoist
+  class PCG32
+    MULTIPLIER = 6_364_136_223_846_793_005
+    MASK_64 = (1 << 64) - 1
+
+    def initialize(seed, stream = 1)
+      @state = 0
+      @increment = ((stream << 1) | 1) & MASK_64
+      next_uint32
+      @state = (@state + seed) & MASK_64
+      next_uint32
+    end
+
+    def rand(limit = nil)
+      return next_uint32.fdiv(1 << 32) unless limit
+      return integer(limit) if limit.is_a?(Integer)
+      return range(limit) if limit.is_a?(Range)
+      return rand * limit if limit.is_a?(Numeric) && limit.positive?
+
+      raise ArgumentError, "unsupported random limit: #{limit.inspect}"
+    end
+
+    def bytes(length)
+      Array.new(length) { rand(256) }.pack("C*")
+    end
+
+    private
+
+    def integer(limit)
+      raise ArgumentError, "random limit must be positive: #{limit}" unless limit.positive?
+      return 0 if limit == 1
+
+      bits = (limit - 1).bit_length
+      words = (bits + 31) / 32
+      mask = (1 << bits) - 1
+      loop do
+        value = 0
+        words.times { value = (value << 32) | next_uint32 }
+        value &= mask
+        return value if value < limit
+      end
+    end
+
+    def range(value)
+      first = value.begin
+      last = value.end
+      if first.is_a?(Integer) && last.is_a?(Integer)
+        size = last - first + (value.exclude_end? ? 0 : 1)
+        return first + integer(size)
+      end
+      if defined?(::Date) && first.instance_of?(::Date) && last.instance_of?(::Date)
+        size = (last - first).to_i + (value.exclude_end? ? 0 : 1)
+        return first + integer(size)
+      end
+      return first if first == last && !value.exclude_end?
+
+      size = last - first
+      raise ArgumentError, "non-numeric range distance: #{value.inspect}" unless size.is_a?(Numeric)
+      raise ArgumentError, "empty random range: #{value.inspect}" unless size.positive?
+
+      first + (rand * size)
+    rescue NoMethodError
+      raise ArgumentError, "unsupported random range: #{value.inspect}"
+    end
+
+    def next_uint32
+      old_state = @state
+      @state = (old_state * MULTIPLIER + @increment) & MASK_64
+      xor_shifted = (((old_state >> 18) ^ old_state) >> 27) & 0xffffffff
+      rotation = old_state >> 59
+      ((xor_shifted >> rotation) | (xor_shifted << ((-rotation) & 31))) & 0xffffffff
+    end
+  end
+end

data/lib/factory_hoist/rspec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "compatibility"
+require_relative "scheduler"
+
+module FactoryHoist
+  module RSpecDSL
+    def hoist(name, factory = name, *traits, **attributes, &block)
+      name = name.to_sym
+      definitions = if instance_variable_defined?(:@factory_hoist_definitions)
+        @factory_hoist_definitions
+      else
+        @factory_hoist_definitions = {}
+      end
+      raise DuplicateHoistError, "hoist(:#{name}) is already declared in this group" if definitions.key?(name)
+
+      node_path = metadata[:full_description]
+      definition = Definition.new(name, factory, traits.freeze, attributes.freeze, block, node_path)
+      definitions[name] = definition
+      define_method(name) do
+        Runtime.current.fetch(self, name, definition, Scheduler.definitions_for(self.class))
+      end
+    end
+  end
+
+  ::RSpec::Core::ExampleGroup.extend(RSpecDSL)
+  ::RSpec.configure do |config|
+    config.before(:suite) do
+      Compatibility.warn_for_database_cleaner
+      Scheduler.install!
+    end
+    config.around(:each) do |example|
+      local = !Scheduler.definitions_for(example.example_group).empty?
+      Runtime.current.around_example(example, local: local)
+    end
+  end
+end