factory_bot 6.5.1 → 6.5.5

data/README.md

@@ -10,7 +10,7 @@ _[Interested in the history of the project name?][NAME]_
 
 ### Transitioning from factory\_girl?
 
-Check out the [guide](https://github.com/thoughtbot/factory_bot/blob/4-9-0-stable/UPGRADE_FROM_FACTORY_GIRL.md).
+Check out the [guide](https://github.com/thoughtbot/factory_bot/blob/v4.9.0/UPGRADE_FROM_FACTORY_GIRL.md).
 
 
 Documentation
@@ -62,6 +62,7 @@ Useful Tools
 ------------
 
 * [FactoryTrace](https://github.com/djezzzl/factory_trace) - helps to find unused factories and traits.
+* [ruby-lsp-factory_bot](https://github.com/donny741/ruby-lsp-factory_bot) / [ruby-lsp-rails-factory-bot](https://github.com/johansenja/ruby-lsp-rails-factory-bot) - integration with [ruby-lsp](https://github.com/Shopify/ruby-lsp) to provide intellisense
 
 Contributing
 ------------
@@ -96,7 +97,6 @@ We are [available for hire][hire].
 [community]: https://thoughtbot.com/community?utm_source=github
 [hire]: https://thoughtbot.com/hire-us?utm_source=github
 
-
 <!-- END /templates/footer.md -->
 
 [ci-image]: https://github.com/thoughtbot/factory_bot/actions/workflows/build.yml/badge.svg?branch=main

data/lib/factory_bot/attribute_assigner.rb

@@ -72,7 +72,7 @@ module FactoryBot
         non_ignored_attribute_names +
         override_names -
         ignored_attribute_names -
-        alias_names_to_ignore
+        aliased_attribute_names_to_ignore
     end
 
     def non_ignored_attribute_names
@@ -91,22 +91,39 @@ module FactoryBot
       @evaluator.__override_names__
     end
 
+    def attribute_names
+      @attribute_list.names
+    end
+
     def hash_instance_methods_to_respond_to
-      @attribute_list.names + override_names + @build_class.instance_methods
+      attribute_names + override_names + @build_class.instance_methods
     end
 
-    def alias_names_to_ignore
+    ##
+    # Creat a list of attribute names that will be
+    # overridden by an alias, so any defaults can
+    # ignored.
+    #
+    def aliased_attribute_names_to_ignore
       @attribute_list.non_ignored.flat_map { |attribute|
         override_names.map do |override|
-          attribute.name if ignorable_alias?(attribute, override)
+          attribute.name if aliased_attribute?(attribute, override)
         end
       }.compact
     end
 
-    def ignorable_alias?(attribute, override)
-      attribute.alias_for?(override) &&
-        attribute.name != override &&
-        !ignored_attribute_names.include?(override)
+    ##
+    # Is the override an alias for the attribute and not the
+    # actual name of another attribute?
+    #
+    # Note: Checking against the names of all attributes, resolves any
+    #       issues with having both <attribute> and <attribute>_id
+    #       in the same factory.
+    #
+    def aliased_attribute?(attribute, override)
+      return false if attribute_names.include?(override)
+
+      attribute.alias_for?(override)
     end
   end
 end

data/lib/factory_bot/callbacks_observer.rb

@@ -4,11 +4,15 @@ module FactoryBot
     def initialize(callbacks, evaluator)
       @callbacks = callbacks
       @evaluator = evaluator
+      @completed = []
     end
 
     def update(name, result_instance)
       callbacks_by_name(name).each do |callback|
-        callback.run(result_instance, @evaluator)
+        if !completed?(result_instance, callback)
+          callback.run(result_instance, @evaluator)
+          record_completion!(result_instance, callback)
+        end
       end
     end
 
@@ -17,5 +21,19 @@ module FactoryBot
     def callbacks_by_name(name)
       @callbacks.select { |callback| callback.name == name }
     end
+
+    def completed?(instance, callback)
+      key = completion_key_for(instance, callback)
+      @completed.include?(key)
+    end
+
+    def record_completion!(instance, callback)
+      key = completion_key_for(instance, callback)
+      @completed << key
+    end
+
+    def completion_key_for(instance, callback)
+      "#{instance.object_id}-#{callback.object_id}"
+    end
   end
 end

data/lib/factory_bot/definition.rb

@@ -1,11 +1,12 @@
 module FactoryBot
   # @api private
   class Definition
-    attr_reader :defined_traits, :declarations, :name, :registered_enums
+    attr_reader :defined_traits, :declarations, :name, :registered_enums, :uri_manager
     attr_accessor :klass
 
-    def initialize(name, base_traits = [])
+    def initialize(name, base_traits = [], **opts)
       @name = name
+      @uri_manager = opts[:uri_manager]
       @declarations = DeclarationList.new(name)
       @callbacks = []
       @defined_traits = Set.new

data/lib/factory_bot/definition_proxy.rb

@@ -119,10 +119,14 @@ module FactoryBot
     #   end
     #
     # Except that no globally available sequence will be defined.
-    def sequence(name, ...)
-      sequence = Sequence.new(name, ...)
-      FactoryBot::Internal.register_inline_sequence(sequence)
-      add_attribute(name) { increment_sequence(sequence) }
+    def sequence(name, *args, &block)
+      options = args.extract_options!
+      options[:uri_paths] = @definition.uri_manager.to_a
+      args << options
+
+      new_sequence = Sequence.new(name, *args, &block)
+      registered_sequence = __fetch_or_register_sequence(new_sequence)
+      add_attribute(name) { increment_sequence(registered_sequence) }
     end
 
     # Adds an attribute that builds an association. The associated instance will
@@ -169,11 +173,11 @@ module FactoryBot
     end
 
     def factory(name, options = {}, &block)
-      @child_factories << [name, options, block]
+      child_factories << [name, options, block]
     end
 
     def trait(name, &block)
-      @definition.define_trait(Trait.new(name, &block))
+      @definition.define_trait(Trait.new(name, uri_paths: @definition.uri_manager.to_a, &block))
     end
 
     # Creates traits for enumerable values.
@@ -252,5 +256,14 @@ module FactoryBot
     def __valid_association_options?(options)
       options.respond_to?(:has_key?) && options.has_key?(:factory)
     end
+
+    ##
+    # If the inline sequence has already been registered by a parent,
+    # return that one, otherwise register and return the given sequence
+    #
+    def __fetch_or_register_sequence(sequence)
+      FactoryBot::Sequence.find_by_uri(sequence.uri_manager.first) ||
+        FactoryBot::Internal.register_inline_sequence(sequence)
+    end
   end
 end

data/lib/factory_bot/evaluator.rb

@@ -1,4 +1,3 @@
-require "active_support/core_ext/hash/except"
 require "active_support/core_ext/class/attribute"
 
 module FactoryBot
@@ -51,8 +50,15 @@ module FactoryBot
       @overrides.keys
     end
 
-    def increment_sequence(sequence)
-      sequence.next(self)
+    def increment_sequence(sequence, scope: self)
+      value = sequence.next(scope)
+
+      raise if value.respond_to?(:start_with?) && value.start_with?("#<FactoryBot::Declaration")
+
+      value
+    rescue
+      raise ArgumentError, "Sequence '#{sequence.uri_manager.first}' failed to " \
+                          "return a value. Perhaps it needs a scope to operate? (scope: <object>)"
     end
 
     def self.attribute_list

data/lib/factory_bot/factory.rb

@@ -12,7 +12,8 @@ module FactoryBot
       @parent = options[:parent]
       @aliases = options[:aliases] || []
       @class_name = options[:class]
-      @definition = Definition.new(@name, options[:traits] || [])
+      @uri_manager = FactoryBot::UriManager.new(names)
+      @definition = Definition.new(@name, options[:traits] || [], uri_manager: @uri_manager)
       @compiled = false
     end
 
@@ -32,6 +33,7 @@ module FactoryBot
 
     def run(build_strategy, overrides, &block)
       block ||= ->(result) { result }
+
       compile
 
       strategy = StrategyCalculator.new(build_strategy).strategy.new
@@ -43,7 +45,11 @@ module FactoryBot
       evaluation =
         Evaluation.new(evaluator, attribute_assigner, compiled_to_create, observer)
 
-      strategy.result(evaluation).tap(&block)
+      evaluation.notify(:before_all, nil)
+      instance = strategy.result(evaluation).tap(&block)
+      evaluation.notify(:after_all, instance)
+
+      instance
     end
 
     def human_names

data/lib/factory_bot/find_definitions.rb

@@ -2,8 +2,8 @@ module FactoryBot
   class << self
     # An Array of strings specifying locations that should be searched for
     # factory definitions. By default, factory_bot will attempt to require
-    # "factories", "test/factories" and "spec/factories". Only the first
-    # existing file will be loaded.
+    # "factories.rb", "factories/**/*.rb", "test/factories.rb",
+    # "test/factories/**.rb", "spec/factories.rb", and "spec/factories/**.rb".
     attr_accessor :definition_file_paths
   end
 

data/lib/factory_bot/internal.rb

@@ -26,6 +26,7 @@ module FactoryBot
 
       def register_inline_sequence(sequence)
         inline_sequences.push(sequence)
+        sequence
       end
 
       def rewind_inline_sequences
@@ -59,6 +60,22 @@ module FactoryBot
         rewind_inline_sequences
       end
 
+      def 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 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)
@@ -86,6 +103,22 @@ module FactoryBot
         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
+
+      def fail_unregistered_sequence(uri)
+        fail KeyError,
+          "Sequence not registered: '#{uri}'."
+      end
     end
   end
 end

data/lib/factory_bot/registry.rb

@@ -1,4 +1,4 @@
-require "active_support/core_ext/hash/indifferent_access"
+require "active_support/hash_with_indifferent_access"
 
 module FactoryBot
   class Registry

data/lib/factory_bot/sequence.rb

@@ -1,17 +1,33 @@
+require "timeout"
+
 module FactoryBot
   # Sequences are defined using sequence within a FactoryBot.define block.
   # Sequence values are generated using next.
   # @api private
   class Sequence
-    attr_reader :name
+    attr_reader :name, :uri_manager, :aliases
+
+    def self.find(*uri_parts)
+      if uri_parts.empty?
+        fail ArgumentError, "wrong number of arguments, expected 1+)"
+      else
+        find_by_uri FactoryBot::UriManager.build_uri(*uri_parts)
+      end
+    end
+
+    def self.find_by_uri(uri)
+      uri = uri.to_sym
+      (FactoryBot::Internal.sequences.to_a.find { |seq| seq.has_uri?(uri) }) ||
+        (FactoryBot::Internal.inline_sequences.find { |seq| seq.has_uri?(uri) })
+    end
 
     def initialize(name, *args, &proc)
+      options = args.extract_options!
       @name = name
       @proc = proc
-
-      options = args.extract_options!
+      @aliases = options.fetch(:aliases, []).map(&:to_sym)
+      @uri_manager = FactoryBot::UriManager.new(names, paths: options[:uri_paths])
       @value = args.first || 1
-      @aliases = options.fetch(:aliases) { [] }
 
       unless @value.respond_to?(:peek)
         @value = EnumeratorAdapter.new(@value)
@@ -34,10 +50,40 @@ module FactoryBot
       [@name] + @aliases
     end
 
+    def has_name?(test_name)
+      names.include?(test_name.to_sym)
+    end
+
+    def has_uri?(uri)
+      uri_manager.include?(uri)
+    end
+
+    def for_factory?(test_factory_name)
+      FactoryBot::Internal.factory_by_name(factory_name).names.include?(test_factory_name.to_sym)
+    end
+
     def rewind
       @value.rewind
     end
 
+    ##
+    # If it's an Integer based sequence, set the new value directly,
+    # else rewind and seek from the beginning until a match is found.
+    #
+    def set_value(new_value)
+      if can_set_value_directly?(new_value)
+        @value.set_value(new_value)
+      elsif can_set_value_by_index?
+        set_value_by_index(new_value)
+      else
+        seek_value(new_value)
+      end
+    end
+
+    protected
+
+    attr_reader :proc
+
     private
 
     def value
@@ -48,22 +94,103 @@ module FactoryBot
       @value.next
     end
 
+    def can_set_value_by_index?
+      @value.respond_to?(:find_index)
+    end
+
+    ##
+    # Set to the given value, or fail if not found
+    #
+    def set_value_by_index(value)
+      index = @value.find_index(value) || fail_value_not_found(value)
+      @value.rewind
+      index.times { @value.next }
+    end
+
+    ##
+    # Rewind index and seek until the value is found or the max attempts
+    # have been tried. If not found, the sequence is rewound to its original value
+    #
+    def seek_value(value)
+      original_value = @value.peek
+
+      # rewind and search for the new value
+      @value.rewind
+      Timeout.timeout(FactoryBot.sequence_setting_timeout) do
+        loop do
+          return if @value.peek == value
+          increment_value
+        end
+
+        # loop auto-recues a StopIteration error, so if we
+        # reached this point, re-raise it now
+        fail StopIteration
+      end
+    rescue Timeout::Error, StopIteration
+      reset_original_value(original_value)
+      fail_value_not_found(value)
+    end
+
+    def reset_original_value(original_value)
+      @value.rewind
+
+      until @value.peek == original_value
+        increment_value
+      end
+    end
+
+    def can_set_value_directly?(value)
+      return false unless value.is_a?(Integer)
+      return false unless @value.is_a?(EnumeratorAdapter)
+      @value.integer_value?
+    end
+
+    def fail_value_not_found(value)
+      fail ArgumentError, "Unable to find '#{value}' in the sequence."
+    end
+
     class EnumeratorAdapter
-      def initialize(value)
-        @first_value = value
-        @value = value
+      def initialize(initial_value)
+        @initial_value = initial_value
       end
 
       def peek
-        @value
+        value
       end
 
       def next
-        @value = @value.next
+        @value = value.next
       end
 
       def rewind
-        @value = @first_value
+        @value = first_value
+      end
+
+      def set_value(new_value)
+        if new_value >= first_value
+          @value = new_value
+        else
+          fail ArgumentError, "Value cannot be less than: #{@first_value}"
+        end
+      end
+
+      def integer_value?
+        first_value.is_a?(Integer)
+      end
+
+      private
+
+      def first_value
+        @first_value ||= initial_value
+      end
+
+      def value
+        @value ||= initial_value
+      end
+
+      def initial_value
+        @value = @initial_value.respond_to?(:call) ? @initial_value.call : @initial_value
+        @first_value = @value
       end
     end
   end

data/lib/factory_bot/strategy/build.rb

@@ -6,6 +6,8 @@ module FactoryBot
       end
 
       def result(evaluation)
+        evaluation.notify(:before_build, nil)
+
         evaluation.object.tap do |instance|
           evaluation.notify(:after_build, instance)
         end

data/lib/factory_bot/strategy/create.rb

@@ -6,6 +6,8 @@ module FactoryBot
       end
 
       def result(evaluation)
+        evaluation.notify(:before_build, nil)
+
         evaluation.object.tap do |instance|
           evaluation.notify(:after_build, instance)
           evaluation.notify(:before_create, instance)

data/lib/factory_bot/strategy/stub.rb

@@ -102,12 +102,14 @@ module FactoryBot
       end
 
       def set_timestamps(result_instance)
+        timestamp = Time.current
+
         if missing_created_at?(result_instance)
-          result_instance.created_at = Time.current
+          result_instance.created_at = timestamp
         end
 
         if missing_updated_at?(result_instance)
-          result_instance.updated_at = Time.current
+          result_instance.updated_at = timestamp
         end
       end
 

data/lib/factory_bot/syntax/methods.rb

@@ -102,33 +102,80 @@ module FactoryBot
       # @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.
+      # Generates and returns the next value in a global or factory sequence.
       #
       # Arguments:
-      #   name: (Symbol)
-      #     The name of the sequence that a value should be generated for.
+      #   context: (Array of Symbols)
+      #     The definition context of the sequence, with the sequence name
+      #     as the final entry
+      #   scope: (object)(optional)
+      #     The object the sequence should be evaluated within
       #
       # Returns:
       #   The next value in the sequence. (Object)
-      def generate(name)
-        Internal.sequence_by_name(name).next
+      #
+      # Example:
+      #   generate(:my_factory, :my_trair, :my_sequence)
+      #
+      def generate(*uri_parts, scope: nil)
+        uri = FactoryBot::UriManager.build_uri(uri_parts)
+        sequence = Sequence.find_by_uri(uri) ||
+          raise(KeyError,
+            "Sequence not registered: #{FactoryBot::UriManager.build_uri(uri_parts)}")
+
+        increment_sequence(sequence, scope: scope)
       end
 
-      # Generates and returns the list of values in a sequence.
+      # Generates and returns the list of values in a global or factory sequence.
       #
       # Arguments:
-      #   name: (Symbol)
-      #     The name of the sequence that a value should be generated for.
-      #   count: (Fixnum)
-      #     Count of values
+      #   uri_parts: (Array of Symbols)
+      #     The definition context of the sequence, with the sequence name
+      #     as the final entry
+      #   scope: (object)(optional)
+      #     The object the sequence should be evaluated within
       #
       # Returns:
       #   The next value in the sequence. (Object)
-      def generate_list(name, count)
+      #
+      # Example:
+      #   generate_list(:my_factory, :my_trair, :my_sequence, 5)
+      #
+      def generate_list(*uri_parts, count, scope: nil)
+        uri = FactoryBot::UriManager.build_uri(uri_parts)
+        sequence = Sequence.find_by_uri(uri) ||
+          raise(KeyError, "Sequence not registered: '#{uri}'")
+
         (1..count).map do
-          Internal.sequence_by_name(name).next
+          increment_sequence(sequence, scope: scope)
         end
       end
+
+      # ======================================================================
+      # = PRIVATE
+      # ======================================================================
+      #
+      private
+
+      ##
+      # Increments the given sequence and returns the value.
+      #
+      # Arguments:
+      #   sequence:
+      #     The sequence instance
+      #   scope: (object)(optional)
+      #     The object the sequence should be evaluated within
+      #
+      def increment_sequence(sequence, scope: nil)
+        value = sequence.next(scope)
+
+        raise if value.respond_to?(:start_with?) && value.start_with?("#<FactoryBot::Declaration")
+
+        value
+      rescue
+        raise ArgumentError, "Sequence '#{sequence.uri_manager.first}' failed to " \
+                            "return a value. Perhaps it needs a scope to operate? (scope: <object>)"
+      end
     end
   end
 end

data/lib/factory_bot/trait.rb

@@ -1,12 +1,17 @@
 module FactoryBot
   # @api private
   class Trait
-    attr_reader :name, :definition
+    attr_reader :name, :uid, :definition
 
-    def initialize(name, &block)
+    delegate :add_callback, :declare_attribute, :to_create, :define_trait, :constructor,
+      :callbacks, :attributes, :klass, :klass=, to: :@definition
+
+    def initialize(name, **options, &block)
       @name = name.to_s
       @block = block
-      @definition = Definition.new(@name)
+      @uri_manager = FactoryBot::UriManager.new(names, paths: options[:uri_paths])
+
+      @definition = Definition.new(@name, uri_manager: @uri_manager)
       proxy = FactoryBot::DefinitionProxy.new(@definition)
 
       if block
@@ -15,12 +20,9 @@ module FactoryBot
     end
 
     def clone
-      Trait.new(name, &block)
+      Trait.new(name, uri_paths: definition.uri_manager.paths, &block)
     end
 
-    delegate :add_callback, :declare_attribute, :to_create, :define_trait, :constructor,
-      :callbacks, :attributes, :klass, :klass=, to: :@definition
-
     def names
       [@name]
     end