factory_bot 4.8.2 → 5.2.0

data/lib/factory_bot/internal.rb

@@ -0,0 +1,104 @@
+module FactoryBot
+  # @api private
+  module Internal
+    class << self
+      delegate :after,
+               :before,
+               :callback_names,
+               :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)
+      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)
+        traits.find(name)
+      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 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
+
+      def register_default_callbacks
+        register_callback(:after_create)
+        register_callback(:after_build)
+        register_callback(:after_stub)
+        register_callback(:before_create)
+      end
+
+      def register_callback(name)
+        name = name.to_sym
+        callback_names << name
+      end
+    end
+  end
+end

data/lib/factory_bot/linter.rb

@@ -1,10 +1,10 @@
 module FactoryBot
   class Linter
-
-    def initialize(factories, linting_strategy, factory_strategy = :create)
+    def initialize(factories, strategy: :create, traits: false, verbose: false)
       @factories_to_lint = factories
-      @linting_method = "lint_#{linting_strategy}"
-      @factory_strategy = factory_strategy
+      @factory_strategy = strategy
+      @traits = traits
+      @verbose = verbose
       @invalid_factories = calculate_invalid_factories
     end
 
@@ -20,7 +20,7 @@ module FactoryBot
 
     def calculate_invalid_factories
       factories_to_lint.reduce(Hash.new([])) do |result, factory|
-        errors = send(@linting_method, factory)
+        errors = lint(factory)
         result[factory] |= errors unless errors.empty?
         result
       end
@@ -37,6 +37,13 @@ module FactoryBot
         "* #{location} - #{message} (#{@wrapped_error.class.name})"
       end
 
+      def verbose_message
+        <<~MESSAGE
+          #{message}
+            #{@wrapped_error.backtrace.join("\n  ")}
+        MESSAGE
+      end
+
       def location
         @factory.name
       end
@@ -53,12 +60,20 @@ module FactoryBot
       end
     end
 
+    def lint(factory)
+      if @traits
+        lint_factory(factory) + lint_traits(factory)
+      else
+        lint_factory(factory)
+      end
+    end
+
     def lint_factory(factory)
       result = []
       begin
         FactoryBot.public_send(factory_strategy, factory.name)
-      rescue => error
-        result |= [FactoryError.new(error, factory)]
+      rescue StandardError => e
+        result |= [FactoryError.new(e, factory)]
       end
       result
     end
@@ -68,30 +83,32 @@ module FactoryBot
       factory.definition.defined_traits.map(&:name).each do |trait_name|
         begin
           FactoryBot.public_send(factory_strategy, factory.name, trait_name)
-        rescue => error
+        rescue StandardError => e
           result |=
-              [FactoryTraitError.new(error, factory, trait_name)]
+            [FactoryTraitError.new(e, factory, trait_name)]
         end
       end
       result
     end
 
-    def lint_factory_and_traits(factory)
-      errors = lint_factory(factory)
-      errors |= lint_traits(factory)
-      errors
-    end
-
     def error_message
       lines = invalid_factories.map do |_factory, exceptions|
-        exceptions.map(&:message)
+        exceptions.map(&error_message_type)
       end.flatten
 
-      <<-ERROR_MESSAGE.strip
-The following factories are invalid:
+      <<~ERROR_MESSAGE.strip
+        The following factories are invalid:
 
-#{lines.join("\n")}
+        #{lines.join("\n")}
       ERROR_MESSAGE
     end
+
+    def error_message_type
+      if @verbose
+        :verbose_message
+      else
+        :message
+      end
+    end
   end
 end

data/lib/factory_bot/null_factory.rb

@@ -8,11 +8,14 @@ module FactoryBot
     end
 
     delegate :defined_traits, :callbacks, :attributes, :constructor,
-      :to_create, to: :definition
+             :to_create, to: :definition
 
     def compile; end
+
     def class_name; end
+
     def evaluator_class; FactoryBot::Evaluator; end
+
     def hierarchy_class; FactoryBot::DefinitionHierarchy; end
   end
 end

data/lib/factory_bot/null_object.rb

@@ -13,11 +13,11 @@ module FactoryBot
       end
     end
 
-    def respond_to?(method, include_private=false)
+    def respond_to?(method, _include_private = false)
       @methods_to_respond_to.include? method.to_s
     end
 
-    def respond_to_missing?(*args)
+    def respond_to_missing?(*)
       false
     end
   end

data/lib/factory_bot/registry.rb

@@ -1,3 +1,5 @@
+require "active_support/core_ext/hash/indifferent_access"
+
 module FactoryBot
   class Registry
     include Enumerable
@@ -6,7 +8,7 @@ module FactoryBot
 
     def initialize(name)
       @name  = name
-      @items = Decorator::ClassKeyHash.new({})
+      @items = ActiveSupport::HashWithIndifferentAccess.new
     end
 
     def clear
@@ -18,11 +20,9 @@ module FactoryBot
     end
 
     def find(name)
-      if registered?(name)
-        @items[name]
-      else
-        raise ArgumentError, "#{@name} not registered: #{name}"
-      end
+      @items.fetch(name)
+    rescue KeyError => e
+      raise key_error_with_custom_message(e)
     end
 
     alias :[] :find
@@ -34,5 +34,14 @@ module FactoryBot
     def registered?(name)
       @items.key?(name)
     end
+
+    private
+
+    def key_error_with_custom_message(key_error)
+      message = key_error.message.sub("key not found", "#{@name} not registered")
+      error = KeyError.new(message)
+      error.set_backtrace(key_error.backtrace)
+      error
+    end
   end
 end

data/lib/factory_bot/reload.rb

@@ -1,8 +1,8 @@
 module FactoryBot
   def self.reload
-    reset_configuration
-    register_default_strategies
-    register_default_callbacks
+    Internal.reset_configuration
+    Internal.register_default_strategies
+    Internal.register_default_callbacks
     find_definitions
   end
 end

data/lib/factory_bot/sequence.rb

@@ -1,5 +1,4 @@
 module FactoryBot
-
   # Sequences are defined using sequence within a FactoryBot.define block.
   # Sequence values are generated using next.
   # @api private
@@ -35,6 +34,10 @@ module FactoryBot
       [@name] + @aliases
     end
 
+    def rewind
+      @value.rewind
+    end
+
     private
 
     def value
@@ -47,6 +50,7 @@ module FactoryBot
 
     class EnumeratorAdapter
       def initialize(value)
+        @first_value = value
         @value = value
       end
 
@@ -57,6 +61,10 @@ module FactoryBot
       def next
         @value = @value.next
       end
+
+      def rewind
+        @value = @first_value
+      end
     end
   end
 end

data/lib/factory_bot/strategy/null.rb

@@ -1,11 +1,9 @@
 module FactoryBot
   module Strategy
     class Null
-      def association(runner)
-      end
+      def association(runner); end
 
-      def result(evaluation)
-      end
+      def result(evaluation); end
     end
   end
 end

data/lib/factory_bot/strategy/stub.rb

@@ -6,17 +6,14 @@ module FactoryBot
       DISABLED_PERSISTENCE_METHODS = [
         :connection,
         :decrement!,
-        :decrement,
         :delete,
         :destroy!,
         :destroy,
         :increment!,
-        :increment,
         :reload,
         :save!,
         :save,
         :toggle!,
-        :toggle,
         :touch,
         :update!,
         :update,
@@ -34,7 +31,8 @@ module FactoryBot
       def result(evaluation)
         evaluation.object.tap do |instance|
           stub_database_interaction_on_result(instance)
-          clear_changed_attributes_on_result(instance)
+          set_timestamps(instance)
+          clear_changes_information(instance)
           evaluation.notify(:after_stub, instance)
         end
       end
@@ -46,15 +44,17 @@ module FactoryBot
       end
 
       def stub_database_interaction_on_result(result_instance)
-        result_instance.id ||= next_id
+        if has_settable_id?(result_instance)
+          result_instance.id ||= next_id
+        end
 
         result_instance.instance_eval do
           def persisted?
-            !new_record?
+            true
           end
 
           def new_record?
-            id.nil?
+            false
           end
 
           def destroyed?
@@ -63,48 +63,44 @@ module FactoryBot
 
           DISABLED_PERSISTENCE_METHODS.each do |write_method|
             define_singleton_method(write_method) do |*args|
-              raise "stubbed models are not allowed to access the database - #{self.class}##{write_method}(#{args.join(",")})"
+              raise "stubbed models are not allowed to access the database - "\
+                    "#{self.class}##{write_method}(#{args.join(',')})"
             end
           end
         end
+      end
 
-        created_at_missing_default = result_instance.respond_to?(:created_at) && !result_instance.created_at
-        result_instance_missing_created_at = !result_instance.respond_to?(:created_at)
+      def has_settable_id?(result_instance)
+        !result_instance.class.respond_to?(:primary_key) ||
+          result_instance.class.primary_key
+      end
 
-        if created_at_missing_default || result_instance_missing_created_at
-          result_instance.instance_eval do
-            def created_at
-              @created_at ||= Time.now.in_time_zone
-            end
-          end
+      def clear_changes_information(result_instance)
+        if result_instance.respond_to?(:clear_changes_information)
+          result_instance.clear_changes_information
         end
+      end
 
-        has_updated_at = result_instance.respond_to?(:updated_at)
-        updated_at_no_default = has_updated_at && !result_instance.updated_at
-        result_instance_missing_updated_at = !has_updated_at
-
-        if updated_at_no_default || result_instance_missing_updated_at
-          result_instance.instance_eval do
-            def updated_at
-              @updated_at ||= Time.current
-            end
-          end
+      def set_timestamps(result_instance)
+        if missing_created_at?(result_instance)
+          result_instance.created_at = Time.current
         end
-      end
 
-      def clear_changed_attributes_on_result(result_instance)
-        unless result_instance.respond_to?(:clear_changes_information)
-          result_instance.extend ActiveModelDirtyBackport
+        if missing_updated_at?(result_instance)
+          result_instance.updated_at = Time.current
         end
+      end
 
-        result_instance.clear_changes_information
+      def missing_created_at?(result_instance)
+        result_instance.respond_to?(:created_at) &&
+          result_instance.respond_to?(:created_at=) &&
+          result_instance.created_at.blank?
       end
-    end
 
-    module ActiveModelDirtyBackport
-      def clear_changes_information
-        @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      def missing_updated_at?(result_instance)
+        result_instance.respond_to?(:updated_at) &&
+          result_instance.respond_to?(:updated_at=) &&
+          result_instance.updated_at.blank?
       end
     end
   end

data/lib/factory_bot/strategy_calculator.rb

@@ -20,7 +20,7 @@ module FactoryBot
     end
 
     def strategy_name_to_object
-      FactoryBot.strategy_by_name(@name_or_object)
+      FactoryBot::Internal.strategy_by_name(@name_or_object)
     end
   end
 end

data/lib/factory_bot/strategy_syntax_method_registrar.rb

@@ -11,6 +11,14 @@ module FactoryBot
       define_pair_strategy_method
     end
 
+    def self.with_index(block, index)
+      if block&.arity == 2
+        ->(instance) { block.call(instance, index) }
+      else
+        block
+      end
+    end
+
     private
 
     def define_singular_strategy_method
@@ -29,7 +37,10 @@ module FactoryBot
           raise ArgumentError, "count missing for #{strategy_name}_list"
         end
 
-        amount.times.map { send(strategy_name, name, *traits_and_overrides, &block) }
+        Array.new(amount) do |i|
+          block_with_index = StrategySyntaxMethodRegistrar.with_index(block, i)
+          send(strategy_name, name, *traits_and_overrides, &block_with_index)
+        end
       end
     end
 
@@ -37,7 +48,7 @@ module FactoryBot
       strategy_name = @strategy_name
 
       define_syntax_method("#{strategy_name}_pair") do |name, *traits_and_overrides, &block|
-        2.times.map { send(strategy_name, name, *traits_and_overrides, &block) }
+        Array.new(2) { send(strategy_name, name, *traits_and_overrides, &block) }
       end
     end
 

data/lib/factory_bot/syntax/default.rb

@@ -17,7 +17,7 @@ module FactoryBot
           proxy = FactoryBot::DefinitionProxy.new(factory.definition)
           proxy.instance_eval(&block) if block_given?
 
-          FactoryBot.register_factory(factory)
+          Internal.register_factory(factory)
 
           proxy.child_factories.each do |(child_name, child_options, child_block)|
             parent_factory = child_options.delete(:parent) || name
@@ -26,41 +26,29 @@ module FactoryBot
         end
 
         def sequence(name, *args, &block)
-          FactoryBot.register_sequence(Sequence.new(name, *args, &block))
+          Internal.register_sequence(Sequence.new(name, *args, &block))
         end
 
         def trait(name, &block)
-          FactoryBot.register_trait(Trait.new(name, &block))
-        end
-
-        def to_create(&block)
-          FactoryBot.to_create(&block)
-        end
-
-        def skip_create
-          FactoryBot.skip_create
-        end
-
-        def initialize_with(&block)
-          FactoryBot.initialize_with(&block)
+          Internal.register_trait(Trait.new(name, &block))
         end
 
         def self.run(block)
           new.instance_eval(&block)
         end
 
-        delegate :before, :after, :callback, to: :configuration
-
-        private
-
-        def configuration
-          FactoryBot.configuration
-        end
+        delegate :after,
+                 :before,
+                 :callback,
+                 :initialize_with,
+                 :skip_create,
+                 :to_create,
+                 to: FactoryBot::Internal
       end
 
       class ModifyDSL
-        def factory(name, options = {}, &block)
-          factory = FactoryBot.factory_by_name(name)
+        def factory(name, _options = {}, &block)
+          factory = Internal.factory_by_name(name)
           proxy = FactoryBot::DefinitionProxy.new(factory.definition.overridable)
           proxy.instance_eval(&block)
         end

data/lib/factory_bot/syntax/methods.rb

@@ -2,8 +2,8 @@ module FactoryBot
   module Syntax
     ## This module is a container for all strategy methods provided by
     ## FactoryBot. This includes all the default strategies provided ({Methods#build},
-    ## {Methods#create}, {Methods#build_stubbed}, and {Methods#attributes_for}), as well as
-    ## the complementary *_list methods.
+    ## {Methods#create}, {Methods#build_stubbed}, and {Methods#attributes_for}), as
+    ## well as the complementary *_list and *_pair methods.
     ## @example singular factory execution
     ##   # basic use case
     ##   build(:completed_order)
@@ -30,7 +30,7 @@ module FactoryBot
     ##   # factory with traits and attribute override
     ##   build_stubbed_list(:user, 15, :admin, :male, name: "John Doe")
     module Methods
-      # @!parse FactoryBot.register_default_strategies
+      # @!parse FactoryBot::Internal.register_default_strategies
       # @!method build(name, *traits_and_overrides, &block)
       # (see #strategy_method)
       # Builds a registered factory by name.
@@ -51,22 +51,38 @@ module FactoryBot
       # Generates a hash of attributes for a registered factory by name.
       # @return [Hash] hash of attributes for the factory
 
-      # @!method build_list(name, amount, *traits_and_overrides)
+      # @!method build_list(name, amount, *traits_and_overrides, &block)
       # (see #strategy_method_list)
       # @return [Array] array of built objects defined by the factory
 
-      # @!method create_list(name, amount, *traits_and_overrides)
+      # @!method create_list(name, amount, *traits_and_overrides, &block)
       # (see #strategy_method_list)
       # @return [Array] array of created objects defined by the factory
 
-      # @!method build_stubbed_list(name, amount, *traits_and_overrides)
+      # @!method build_stubbed_list(name, amount, *traits_and_overrides, &block)
       # (see #strategy_method_list)
       # @return [Array] array of stubbed objects defined by the factory
 
-      # @!method attributes_for_list(name, amount, *traits_and_overrides)
+      # @!method attributes_for_list(name, amount, *traits_and_overrides, &block)
       # (see #strategy_method_list)
       # @return [Array<Hash>] array of attribute hashes for the factory
 
+      # @!method build_pair(name, *traits_and_overrides, &block)
+      # (see #strategy_method_pair)
+      # @return [Array] pair of built objects defined by the factory
+
+      # @!method create_pair(name, *traits_and_overrides, &block)
+      # (see #strategy_method_pair)
+      # @return [Array] pair of created objects defined by the factory
+
+      # @!method build_stubbed_pair(name, *traits_and_overrides, &block)
+      # (see #strategy_method_pair)
+      # @return [Array] pair of stubbed objects defined by the factory
+
+      # @!method attributes_for_pair(name, *traits_and_overrides, &block)
+      # (see #strategy_method_pair)
+      # @return [Array<Hash>] pair of attribute hashes for the factory
+
       # @!method strategy_method
       # @!visibility private
       # @param [Symbol] name the name of the factory to build
@@ -78,6 +94,13 @@ module FactoryBot
       # @param [Symbol] name the name of the factory to execute
       # @param [Integer] amount the number of instances to execute
       # @param [Array<Symbol, Symbol, Hash>] traits_and_overrides splat args traits and a hash of overrides
+      # @param [Proc] block block to be executed
+
+      # @!method strategy_method_pair
+      # @!visibility private
+      # @param [Symbol] name the name of the factory to execute
+      # @param [Array<Symbol, Symbol, Hash>] traits_and_overrides splat args traits and a hash of overrides
+      # @param [Proc] block block to be executed
 
       # Generates and returns the next value in a sequence.
       #
@@ -88,7 +111,7 @@ module FactoryBot
       # Returns:
       #   The next value in the sequence. (Object)
       def generate(name)
-        FactoryBot.sequence_by_name(name).next
+        Internal.sequence_by_name(name).next
       end
 
       # Generates and returns the list of values in a sequence.
@@ -103,7 +126,7 @@ module FactoryBot
       #   The next value in the sequence. (Object)
       def generate_list(name, count)
         (1..count).map do
-          FactoryBot.sequence_by_name(name).next
+          Internal.sequence_by_name(name).next
         end
       end
     end

data/lib/factory_bot/syntax.rb

@@ -1,5 +1,5 @@
-require 'factory_bot/syntax/methods'
-require 'factory_bot/syntax/default'
+require "factory_bot/syntax/methods"
+require "factory_bot/syntax/default"
 
 module FactoryBot
   module Syntax