factory_bot 6.2.1 → 6.5.4

data/lib/factory_bot/evaluation.rb

@@ -1,13 +1,10 @@
-require "observer"
-
 module FactoryBot
   class Evaluation
-    include Observable
-
-    def initialize(evaluator, attribute_assigner, to_create)
+    def initialize(evaluator, attribute_assigner, to_create, observer)
       @evaluator = evaluator
       @attribute_assigner = attribute_assigner
       @to_create = to_create
+      @observer = observer
     end
 
     delegate :object, :hash, to: :@attribute_assigner
@@ -20,8 +17,7 @@ module FactoryBot
     end
 
     def notify(name, result_instance)
-      changed
-      notify_observers(name, result_instance)
+      @observer.update(name, result_instance)
     end
   end
 end

data/lib/factory_bot/evaluator.rb

@@ -35,14 +35,13 @@ module FactoryBot
 
     attr_accessor :instance
 
-    def method_missing(method_name, *args, &block)
+    def method_missing(method_name, ...)
       if @instance.respond_to?(method_name)
-        @instance.send(method_name, *args, &block)
+        @instance.send(method_name, ...)
       else
-        SyntaxRunner.new.send(method_name, *args, &block)
+        SyntaxRunner.new.send(method_name, ...)
       end
     end
-    ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
 
     def respond_to_missing?(method_name, _include_private = false)
       @instance.respond_to?(method_name) || SyntaxRunner.new.respond_to?(method_name)

data/lib/factory_bot/factory.rb

@@ -12,16 +12,20 @@ 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
 
     delegate :add_callback, :declare_attribute, :to_create, :define_trait, :constructor,
-      :defined_traits, :inherit_traits, :append_traits, to: :@definition
+      :defined_traits, :defined_traits_names, :inherit_traits, :append_traits,
+      to: :@definition
 
     def build_class
       @build_class ||= if class_name.is_a? Class
         class_name
+      elsif class_name.to_s.safe_constantize
+        class_name.to_s.safe_constantize
       else
         class_name.to_s.camelize.constantize
       end
@@ -36,9 +40,9 @@ module FactoryBot
       evaluator = evaluator_class.new(strategy, overrides.symbolize_keys)
       attribute_assigner = AttributeAssigner.new(evaluator, build_class, &compiled_constructor)
 
+      observer = CallbacksObserver.new(callbacks, evaluator)
       evaluation =
-        Evaluation.new(evaluator, attribute_assigner, compiled_to_create)
-      evaluation.add_observer(CallbacksObserver.new(callbacks, evaluator))
+        Evaluation.new(evaluator, attribute_assigner, compiled_to_create, observer)
 
       strategy.result(evaluation).tap(&block)
     end
@@ -83,7 +87,7 @@ module FactoryBot
     def compile
       unless @compiled
         parent.compile
-        parent.defined_traits.each { |trait| define_trait(trait) }
+        inherit_parent_traits
         @definition.compile(build_class)
         build_hierarchy
         @compiled = true
@@ -151,6 +155,13 @@ module FactoryBot
       end
     end
 
+    def inherit_parent_traits
+      parent.defined_traits.each do |trait|
+        next if defined_traits_names.include?(trait.name)
+        define_trait(trait.clone)
+      end
+    end
+
     def initialize_copy(source)
       super
       @definition = @definition.clone

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
@@ -39,8 +40,8 @@ module FactoryBot
         trait
       end
 
-      def trait_by_name(name)
-        traits.find(name)
+      def trait_by_name(name, klass)
+        traits.find(name).tap { |t| t.klass = klass }
       end
 
       def register_sequence(sequence)
@@ -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/linter.rb

@@ -70,7 +70,7 @@ module FactoryBot
     def lint_factory(factory)
       result = []
       begin
-        FactoryBot.public_send(factory_strategy, factory.name)
+        in_transaction { FactoryBot.public_send(factory_strategy, factory.name) }
       rescue => e
         result |= [FactoryError.new(e, factory)]
       end
@@ -80,7 +80,7 @@ module FactoryBot
     def lint_traits(factory)
       result = []
       factory.definition.defined_traits.map(&:name).each do |trait_name|
-        FactoryBot.public_send(factory_strategy, factory.name, trait_name)
+        in_transaction { FactoryBot.public_send(factory_strategy, factory.name, trait_name) }
       rescue => e
         result |= [FactoryTraitError.new(e, factory, trait_name)]
       end
@@ -106,5 +106,16 @@ module FactoryBot
         :message
       end
     end
+
+    def in_transaction
+      if defined?(ActiveRecord::Base)
+        ActiveRecord::Base.transaction do
+          yield
+          raise ActiveRecord::Rollback
+        end
+      else
+        yield
+      end
+    end
   end
 end

data/lib/factory_bot/registry.rb

@@ -39,9 +39,21 @@ module FactoryBot
 
     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
+      new_key_error(message, key_error).tap do |error|
+        error.set_backtrace(key_error.backtrace)
+      end
+    end
+
+    # detailed_message introduced in Ruby 3.2 for cleaner integration with
+    # did_you_mean. See https://bugs.ruby-lang.org/issues/18564
+    if KeyError.method_defined?(:detailed_message)
+      def new_key_error(message, key_error)
+        KeyError.new(message, key: key_error.key, receiver: key_error.receiver)
+      end
+    else
+      def new_key_error(message, _)
+        KeyError.new(message)
+      end
     end
   end
 end

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,6 +94,61 @@ 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
@@ -65,6 +166,18 @@ module FactoryBot
       def rewind
         @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
     end
   end
 end

data/lib/factory_bot/strategy/stub.rb

@@ -47,13 +47,17 @@ module FactoryBot
 
       private
 
-      def next_id
-        @@next_id += 1
+      def next_id(result_instance)
+        if uuid_primary_key?(result_instance)
+          SecureRandom.uuid
+        else
+          @@next_id += 1
+        end
       end
 
       def stub_database_interaction_on_result(result_instance)
         if has_settable_id?(result_instance)
-          result_instance.id ||= next_id
+          result_instance.id ||= next_id(result_instance)
         end
 
         result_instance.instance_eval do
@@ -66,12 +70,12 @@ module FactoryBot
           end
 
           def destroyed?
-            nil
+            false
           end
 
           DISABLED_PERSISTENCE_METHODS.each do |write_method|
             define_singleton_method(write_method) do |*args|
-              raise "stubbed models are not allowed to access the database - "\
+              raise "stubbed models are not allowed to access the database - " \
                     "#{self.class}##{write_method}(#{args.join(",")})"
             end
           end
@@ -79,8 +83,16 @@ module FactoryBot
       end
 
       def has_settable_id?(result_instance)
-        !result_instance.class.respond_to?(:primary_key) ||
-          result_instance.class.primary_key
+        result_instance.respond_to?(:id=) &&
+          (!result_instance.class.respond_to?(:primary_key) ||
+          result_instance.class.primary_key)
+      end
+
+      def uuid_primary_key?(result_instance)
+        result_instance.respond_to?(:column_for_attribute) &&
+          (column = result_instance.column_for_attribute(result_instance.class.primary_key)) &&
+          column.respond_to?(:sql_type) &&
+          column.sql_type == "uuid"
       end
 
       def clear_changes_information(result_instance)
@@ -90,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/default.rb

@@ -25,8 +25,8 @@ module FactoryBot
           end
         end
 
-        def sequence(name, *args, &block)
-          Internal.register_sequence(Sequence.new(name, *args, &block))
+        def sequence(name, ...)
+          Internal.register_sequence(Sequence.new(name, ...))
         end
 
         def trait(name, &block)

data/lib/factory_bot/syntax/methods.rb

@@ -102,33 +102,82 @@ 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(uri, 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(uri, sequence, scope: scope)
         end
       end
+
+      # ======================================================================
+      # = PRIVATE
+      # ======================================================================
+      #
+      private
+
+      ##
+      # Increments the given sequence and returns the value.
+      #
+      # Arguments:
+      #   uri: (Symbol)
+      #     The URI for the sequence
+      #   sequence:
+      #     The sequence instance
+      #   scope: (object)(optional)
+      #     The object the sequence should be evaluated within
+      #
+      def increment_sequence(uri, sequence, scope: nil)
+        value = sequence.next(scope)
+
+        raise if value.respond_to?(:start_with?) && value.start_with?("#<FactoryBot::Declaration")
+
+        value
+      rescue
+        raise ArgumentError, "Sequence '#{uri}' 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
@@ -14,8 +19,9 @@ module FactoryBot
       end
     end
 
-    delegate :add_callback, :declare_attribute, :to_create, :define_trait, :constructor,
-      :callbacks, :attributes, to: :@definition
+    def clone
+      Trait.new(name, uri_paths: definition.uri_manager.paths, &block)
+    end
 
     def names
       [@name]

data/lib/factory_bot/uri_manager.rb

@@ -0,0 +1,63 @@
+module FactoryBot
+  # @api private
+  class UriManager
+    attr_reader :endpoints, :paths, :uri_list
+
+    delegate :size, :any?, :empty?, :each?, :include?, :first, to: :@uri_list
+    delegate :build_uri, to: :class
+
+    # Concatenate the parts, sripping leading/following slashes
+    # and returning a Symbolized String or nil.
+    #
+    # Example:
+    #   build_uri(:my_factory, :my_trait, :my_sequence)
+    #   #=> :"myfactory/my_trait/my_sequence"
+    #
+    def self.build_uri(*parts)
+      return nil if parts.empty?
+
+      parts.join("/")
+        .sub(/\A\/+/, "")
+        .sub(/\/+\z/, "")
+        .tr(" ", "_")
+        .to_sym
+    end
+
+    # Configures the new UriManager
+    #
+    # Arguments:
+    #   endpoints: (Array of Strings or Symbols)
+    #     the objects endpoints.
+    #
+    #   paths: (Array of Strings or Symbols)
+    #     the parent URIs to prepend to each endpoint
+    #
+    def initialize(*endpoints, paths: [])
+      if endpoints.empty?
+        fail ArgumentError, "wrong number of arguments (given 0, expected 1+)"
+      end
+
+      @uri_list = []
+      @endpoints = endpoints.flatten
+      @paths = Array(paths).flatten
+
+      build_uri_list
+    end
+
+    def to_a
+      @uri_list.dup
+    end
+
+    private
+
+    def build_uri_list
+      @endpoints.each do |endpoint|
+        if @paths.any?
+          @paths.each { |path| @uri_list << build_uri(path, endpoint) }
+        else
+          @uri_list << build_uri(endpoint)
+        end
+      end
+    end
+  end
+end

data/lib/factory_bot/version.rb

@@ -1,3 +1,3 @@
 module FactoryBot
-  VERSION = "6.2.1".freeze
+  VERSION = "6.5.4".freeze
 end