Refactor Internal module

lib/factory_bot.rb

@@ -7,7 +7,6 @@
 
 require "factory_bot/internal"
 require "factory_bot/definition_hierarchy"
-require "factory_bot/configuration"
 require "factory_bot/errors"
 require "factory_bot/factory_runner"
 require "factory_bot/strategy_syntax_method_registrar"
@@ -111,8 +110,8 @@ class << self
     #     set_sequence("factory_name/trait_name/sequence_name", 450)
     delegate :factories,
       :register_strategy,
-      :rewind_sequences,
       :rewind_sequence,
+      :rewind_sequences,
       :set_sequence,
       :strategy_by_name,
       to: Internal

lib/factory_bot/definition.rb

@@ -107,6 +107,7 @@ def register_enum(enum)
     def define_constructor(&block)
       @constructor = block
     end
+    alias_method :initialize_with, :define_constructor
 
     def before(*names, &block)
       callback(*names.map { |name| "before_#{name}" }, &block)

lib/factory_bot/internal.rb

@@ -1,3 +1,9 @@
+require "factory_bot/internal/definition"
+require "factory_bot/internal/factories"
+require "factory_bot/internal/sequences"
+require "factory_bot/internal/strategies"
+require "factory_bot/internal/traits"
+
 module FactoryBot
   # @api private
   module Internal
@@ -6,119 +12,46 @@ class << self
         :before,
         :callbacks,
         :constructor,
-        :factories,
         :initialize_with,
-        :inline_sequences,
-        :sequences,
         :skip_create,
         :strategies,
         :to_create,
-        :traits,
-        to: :configuration
-
-      def configuration
-        @configuration ||= Configuration.new
-      end
-
-      def reset_configuration
-        @configuration = nil
-      end
-
-      def register_inline_sequence(sequence)
-        inline_sequences.push(sequence)
-        sequence
-      end
-
-      def rewind_inline_sequences
-        inline_sequences.each(&:rewind)
-      end
-
-      def register_trait(trait)
-        trait.names.each do |name|
-          traits.register(name, trait)
-        end
-        trait
-      end
-
-      def trait_by_name(name, klass)
-        traits.find(name).tap { |t| t.klass = klass }
-      end
-
-      def register_sequence(sequence)
-        sequence.names.each do |name|
-          sequences.register(name, sequence)
-        end
-        sequence
-      end
-
-      def sequence_by_name(name)
-        sequences.find(name)
-      end
-
-      def rewind_sequences
-        sequences.each(&:rewind)
-        rewind_inline_sequences
-      end
-
-      def rewind_sequence(*uri_parts)
-        fail_argument_count(0, "1+") if uri_parts.empty?
+        to: Internal::Definition
 
-        uri = build_uri(uri_parts)
-        sequence = Sequence.find_by_uri(uri) || fail_unregistered_sequence(uri)
+      delegate :traits,
+        :register_trait,
+        :trait_by_name,
+        to: Internal::Traits
 
-        sequence.rewind
-      end
+      delegate :factories,
+        :register_factory,
+        :factory_by_name,
+        to: Internal::Factories
 
-      def set_sequence(*uri_parts, value)
-        uri = build_uri(uri_parts) || fail_argument_count(uri_parts.size, "2+")
-        sequence = Sequence.find(*uri) || fail_unregistered_sequence(uri)
-
-        sequence.set_value(value)
-      end
-
-      def register_factory(factory)
-        factory.names.each do |name|
-          factories.register(name, factory)
-        end
-        factory
-      end
-
-      def factory_by_name(name)
-        factories.find(name)
-      end
-
-      def register_strategy(strategy_name, strategy_class)
-        strategies.register(strategy_name, strategy_class)
-        StrategySyntaxMethodRegistrar.new(strategy_name).define_strategy_methods
-      end
-
-      def strategy_by_name(name)
-        strategies.find(name)
-      end
-
-      def register_default_strategies
-        register_strategy(:build, FactoryBot::Strategy::Build)
-        register_strategy(:create, FactoryBot::Strategy::Create)
-        register_strategy(:attributes_for, FactoryBot::Strategy::AttributesFor)
-        register_strategy(:build_stubbed, FactoryBot::Strategy::Stub)
-        register_strategy(:null, FactoryBot::Strategy::Null)
-      end
-
-      private
-
-      def build_uri(...)
-        FactoryBot::UriManager.build_uri(...)
-      end
-
-      def fail_argument_count(received, expected)
-        fail ArgumentError,
-          "wrong number of arguments (given #{received}, expected #{expected})"
-      end
+      delegate :sequences,
+        :inline_sequences,
+        :register_inline_sequence,
+        :rewind_inline_sequences,
+        :register_sequence,
+        :sequence_by_name,
+        :rewind_sequence,
+        :rewind_sequences,
+        :set_sequence,
+        to: Internal::Sequences
+
+      delegate :strategies,
+        :register_strategy,
+        :strategy_by_name,
+        :register_default_strategies,
+        to: Internal::Strategies
+    end
 
-      def fail_unregistered_sequence(uri)
-        fail KeyError,
-          "Sequence not registered: '#{uri}'."
-      end
+    def self.reset
+      Internal::Traits.reset
+      Internal::Factories.reset
+      Internal::Sequences.reset
+      Internal::Strategies.reset
+      Internal::Definition.reset
     end
   end
 end

lib/factory_bot/internal/definition.rb

@@ -0,0 +1,29 @@
+module FactoryBot
+  module Internal
+    module Definition
+      def self.definition
+        @definition ||= FactoryBot::Definition.new(:configuration).tap do |definition|
+          definition.to_create(&:save!)
+          definition.initialize_with { new }
+        end
+      end
+
+      def self.reset
+        @definition = nil
+        definition
+      end
+
+      class << self
+        delegate :to_create,
+          :skip_create,
+          :constructor,
+          :before,
+          :after,
+          :callback,
+          :callbacks,
+          :initialize_with,
+          to: :definition
+      end
+    end
+  end
+end

lib/factory_bot/internal/factories.rb

@@ -0,0 +1,24 @@
+module FactoryBot
+  module Internal
+    module Factories
+      def self.factories
+        @factories ||= Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Factory"))
+      end
+
+      def self.reset
+        @factories&.reset
+      end
+
+      def self.register_factory(factory)
+        factory.names.each do |name|
+          factories.register(name, factory)
+        end
+        factory
+      end
+
+      def self.factory_by_name(name)
+        factories.find(name)
+      end
+    end
+  end
+end

lib/factory_bot/internal/sequences.rb

@@ -0,0 +1,77 @@
+module FactoryBot
+  module Internal
+    module Sequences
+      def self.sequences
+        @sequences ||= Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Sequence"))
+      end
+
+      def self.inline_sequences
+        @inline_sequences ||= []
+      end
+
+      def self.reset
+        @sequences&.reset
+        @inline_sequences = []
+        sequences
+      end
+
+      def self.register_inline_sequence(sequence)
+        inline_sequences.push(sequence)
+        sequence
+      end
+
+      def self.rewind_inline_sequences
+        inline_sequences.each(&:rewind)
+      end
+
+      def self.register_sequence(sequence)
+        sequence.names.each do |name|
+          sequences.register(name, sequence)
+        end
+        sequence
+      end
+
+      def self.sequence_by_name(name)
+        sequences.find(name)
+      end
+
+      def self.rewind_sequences
+        sequences.each(&:rewind)
+        rewind_inline_sequences
+      end
+
+      def self.rewind_sequence(*uri_parts)
+        fail_argument_count(0, "1+") if uri_parts.empty?
+
+        uri = build_uri(uri_parts)
+        sequence = Sequence.find_by_uri(uri) || fail_unregistered_sequence(uri)
+
+        sequence.rewind
+      end
+
+      def self.set_sequence(*uri_parts, value)
+        uri = build_uri(uri_parts) || fail_argument_count(uri_parts.size, "2+")
+        sequence = Sequence.find(*uri) || fail_unregistered_sequence(uri)
+
+        sequence.set_value(value)
+      end
+
+      def self.build_uri(...)
+        FactoryBot::UriManager.build_uri(...)
+      end
+      private_class_method :build_uri
+
+      def self.fail_argument_count(received, expected)
+        fail ArgumentError,
+          "wrong number of arguments (given #{received}, expected #{expected})"
+      end
+      private_class_method :fail_argument_count
+
+      def self.fail_unregistered_sequence(uri)
+        fail KeyError,
+          "Sequence not registered: '#{uri}'."
+      end
+      private_class_method :fail_unregistered_sequence
+    end
+  end
+end

lib/factory_bot/internal/strategies.rb

@@ -0,0 +1,30 @@
+module FactoryBot
+  module Internal
+    module Strategies
+      def self.strategies
+        @strategies ||= Registry.new("Strategy")
+      end
+
+      def self.reset
+        @strategies&.reset
+      end
+
+      def self.register_strategy(strategy_name, strategy_class)
+        strategies.register(strategy_name, strategy_class)
+        StrategySyntaxMethodRegistrar.new(strategy_name).define_strategy_methods
+      end
+
+      def self.strategy_by_name(name)
+        strategies.find(name)
+      end
+
+      def self.register_default_strategies
+        register_strategy(:build, FactoryBot::Strategy::Build)
+        register_strategy(:create, FactoryBot::Strategy::Create)
+        register_strategy(:attributes_for, FactoryBot::Strategy::AttributesFor)
+        register_strategy(:build_stubbed, FactoryBot::Strategy::Stub)
+        register_strategy(:null, FactoryBot::Strategy::Null)
+      end
+    end
+  end
+end