factory_bot 6.4.4 → 6.6.0

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/strategy.rb

@@ -0,0 +1,15 @@
+require "factory_bot/strategy/build"
+require "factory_bot/strategy/create"
+require "factory_bot/strategy/attributes_for"
+require "factory_bot/strategy/stub"
+require "factory_bot/strategy/null"
+
+module FactoryBot
+  module Strategy
+    def self.lookup_strategy(name_or_object)
+      return name_or_object if name_or_object.is_a?(Class)
+
+      FactoryBot::Internal.strategy_by_name(name_or_object)
+    end
+  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

@@ -83,52 +83,99 @@ module FactoryBot
       # (see #strategy_method_pair)
       # @return [Array<Hash>] pair of attribute hashes for the factory
 
-      # @!method strategy_method
+      # @!method strategy_method(name, traits_and_overrides, &block)
       # @!visibility private
       # @param [Symbol] name the name of the factory to build
       # @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_list
+      # @!method strategy_method_list(name, amount, traits_and_overrides, &block)
       # @!visibility private
       # @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
+      # @!method strategy_method_pair(name, traits_and_overrides, &block)
       # @!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.
+      # 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
@@ -14,8 +19,9 @@ module FactoryBot
       end
     end
 
-    delegate :add_callback, :declare_attribute, :to_create, :define_trait, :constructor,
-      :callbacks, :attributes, :klass, :klass=, 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.4.4".freeze
+  VERSION = "6.6.0".freeze
 end

data/lib/factory_bot.rb

@@ -1,4 +1,5 @@
 require "set"
+require "active_support"
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/deprecation"
@@ -10,12 +11,7 @@ require "factory_bot/configuration"
 require "factory_bot/errors"
 require "factory_bot/factory_runner"
 require "factory_bot/strategy_syntax_method_registrar"
-require "factory_bot/strategy_calculator"
-require "factory_bot/strategy/build"
-require "factory_bot/strategy/create"
-require "factory_bot/strategy/attributes_for"
-require "factory_bot/strategy/stub"
-require "factory_bot/strategy/null"
+require "factory_bot/strategy"
 require "factory_bot/registry"
 require "factory_bot/null_factory"
 require "factory_bot/null_object"
@@ -45,6 +41,7 @@ require "factory_bot/decorator/attribute_hash"
 require "factory_bot/decorator/disallows_duplicates_registry"
 require "factory_bot/decorator/invocation_tracker"
 require "factory_bot/decorator/new_constructor"
+require "factory_bot/uri_manager"
 require "factory_bot/linter"
 require "factory_bot/version"
 
@@ -57,6 +54,9 @@ module FactoryBot
   mattr_accessor :automatically_define_enum_traits, instance_accessor: false
   self.automatically_define_enum_traits = true
 
+  mattr_accessor :sequence_setting_timeout, instance_accessor: false
+  self.sequence_setting_timeout = 3
+
   # Look for errors in factories and (optionally) their traits.
   # Parameters:
   # factories - which factories to lint; omit for all factories
@@ -72,17 +72,43 @@ module FactoryBot
 
   # Set the starting value for ids when using the build_stubbed strategy
   #
-  # Arguments:
-  # * starting_id +Integer+
-  #   The new starting id value.
+  # @param [Integer] starting_id The new starting id value.
   def self.build_stubbed_starting_id=(starting_id)
     Strategy::Stub.next_id = starting_id - 1
   end
 
   class << self
+    # @!method rewind_sequence(*uri_parts)
+    #   Rewind an individual global or inline sequence.
+    #
+    #   @param [Array<Symbol>, String] uri_parts The components of the sequence URI.
+    #
+    #   @example Rewinding a sequence by its URI parts
+    #     rewind_sequence(:factory_name, :trait_name, :sequence_name)
+    #
+    #   @example Rewinding a sequence by its URI string
+    #     rewind_sequence("factory_name/trait_name/sequence_name")
+    #
+    # @!method set_sequence(*uri_parts, value)
+    #   Set the sequence to a specific value, providing the new value is within
+    #   the sequence set.
+    #
+    #   @param [Array<Symbol>, String] uri_parts The components of the sequence URI.
+    #   @param [Object] value The new value for the sequence. This must be a value that is
+    #     within the sequence definition. For example, you cannot set
+    #     a String sequence to an Integer value.
+    #
+    #   @example
+    #     set_sequence(:factory_name, :trait_name, :sequence_name, 450)
+    #   @example
+    #     set_sequence([:factory_name, :trait_name, :sequence_name], 450)
+    #   @example
+    #     set_sequence("factory_name/trait_name/sequence_name", 450)
     delegate :factories,
       :register_strategy,
       :rewind_sequences,
+      :rewind_sequence,
+      :set_sequence,
       :strategy_by_name,
       to: Internal
   end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: factory_bot
 version: !ruby/object:Gem::Version
-  version: 6.4.4
+  version: 6.6.0
 platform: ruby
 authors:
 - Josh Clayton
 - Joe Ferris
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-27 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -17,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 6.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -68,7 +67,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: cucumber
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -220,25 +233,26 @@ files:
 - lib/factory_bot/registry.rb
 - lib/factory_bot/reload.rb
 - lib/factory_bot/sequence.rb
+- lib/factory_bot/strategy.rb
 - lib/factory_bot/strategy/attributes_for.rb
 - lib/factory_bot/strategy/build.rb
 - lib/factory_bot/strategy/create.rb
 - lib/factory_bot/strategy/null.rb
 - lib/factory_bot/strategy/stub.rb
-- lib/factory_bot/strategy_calculator.rb
 - lib/factory_bot/strategy_syntax_method_registrar.rb
 - lib/factory_bot/syntax.rb
 - lib/factory_bot/syntax/default.rb
 - lib/factory_bot/syntax/methods.rb
 - lib/factory_bot/syntax_runner.rb
 - lib/factory_bot/trait.rb
+- lib/factory_bot/uri_manager.rb
 - lib/factory_bot/version.rb
 homepage: https://github.com/thoughtbot/factory_bot
 licenses:
 - MIT
 metadata:
   changelog_uri: https://github.com/thoughtbot/factory_bot/blob/main/NEWS.md
-post_install_message:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -246,15 +260,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: factory_bot provides a framework and DSL for defining and using model instance
   factories.

data/lib/factory_bot/strategy_calculator.rb

@@ -1,26 +0,0 @@
-module FactoryBot
-  # @api private
-  class StrategyCalculator
-    def initialize(name_or_object)
-      @name_or_object = name_or_object
-    end
-
-    def strategy
-      if strategy_is_object?
-        @name_or_object
-      else
-        strategy_name_to_object
-      end
-    end
-
-    private
-
-    def strategy_is_object?
-      @name_or_object.is_a?(Class)
-    end
-
-    def strategy_name_to_object
-      FactoryBot::Internal.strategy_by_name(@name_or_object)
-    end
-  end
-end