factory_bot 6.4.4 → 6.6.0

data/README.md

@@ -1,20 +1,17 @@
-# factory_bot [![Build Status][ci-image]][ci] [![Code Climate][grade-image]][grade] [![Gem Version][version-image]][version]
+# factory_bot 
+
+[![Build Status][ci-image]][ci] [![Gem Version][version-image]][version]
 
 factory_bot is a fixtures replacement with a straightforward definition syntax, support for multiple build strategies (saved instances, unsaved instances, attribute hashes, and stubbed objects), and support for multiple factories for the same class (user, admin_user, and so on), including factory inheritance.
 
 If you want to use factory_bot with Rails, see
 [factory_bot_rails](https://github.com/thoughtbot/factory_bot_rails).
 
-_[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).
+Interested in the history of the project name? You can find the history [here](https://github.com/thoughtbot/factory_bot/blob/main/NAME.md)
 
+Transitioning from factory\_girl? Check out the [upgrade guide](https://github.com/thoughtbot/factory_bot/blob/v4.9.0/UPGRADE_FROM_FACTORY_GIRL.md).
 
-Documentation
--------------
+## Documentation
 
 See our extensive reference, guides, and cookbook in [the factory_bot book][].
 
@@ -27,8 +24,7 @@ Rails, see [the factory_bot wiki][].
 [the factory_bot book]: https://thoughtbot.github.io/factory_bot
 [the factory_bot wiki]: https://github.com/thoughtbot/factory_bot/wiki
 
-Install
---------
+## Install
 
 Run:
 
@@ -42,13 +38,11 @@ To install the gem manually from your shell, run:
 gem install factory_bot
 ```
 
-Supported Ruby versions
------------------------
+## Supported Ruby versions
 
-Supported Ruby versions are listed in [`.github/workflows/build.yml`](https://github.com/thoughtbot/factory_bot/blob/main/.github/workflows/build.yml)
+Supported Ruby versions are listed in `.github/workflows/build.yml` ([source](https://github.com/thoughtbot/factory_bot/blob/main/.github/workflows/build.yml))
 
-More Information
-----------------
+## More Information
 
 * [Rubygems](https://rubygems.org/gems/factory_bot)
 * [Stack Overflow](https://stackoverflow.com/questions/tagged/factory-bot)
@@ -56,12 +50,11 @@ More Information
 * [GIANT ROBOTS SMASHING INTO OTHER GIANT ROBOTS](https://robots.thoughtbot.com/)
 
 [GETTING_STARTED]: https://github.com/thoughtbot/factory_bot/blob/main/GETTING_STARTED.md
-[NAME]: https://github.com/thoughtbot/factory_bot/blob/main/NAME.md
 
-Useful Tools
-------------
+## 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
 ------------
@@ -75,31 +68,31 @@ community](https://github.com/thoughtbot/factory_bot/graphs/contributors).
 License
 -------
 
-factory_bot is Copyright © 2008-2022 Joe Ferris and thoughtbot. It is free
+factory_bot is Copyright © 2008 Joe Ferris and thoughtbot. It is free
 software, and may be redistributed under the terms specified in the
 [LICENSE] file.
 
 [LICENSE]: https://github.com/thoughtbot/factory_bot/blob/main/LICENSE
 
+<!-- START /templates/footer.md -->
+## About thoughtbot
 
-About thoughtbot
-----------------
-
-![thoughtbot](https://thoughtbot.com/brand_assets/93:44.svg)
+![thoughtbot](https://thoughtbot.com/thoughtbot-logo-for-readmes.svg)
 
-factory_bot is maintained and funded by thoughtbot, inc.
+This repo is maintained and funded by thoughtbot, inc.
 The names and logos for thoughtbot are trademarks of thoughtbot, inc.
 
 We love open source software!
-See [our other projects][community] or
-[hire us][hire] to design, develop, and grow your product.
+See [our other projects][community].
+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
 [ci]: https://github.com/thoughtbot/factory_bot/actions?query=workflow%3ABuild+branch%3Amain
-[grade-image]: https://codeclimate.com/github/thoughtbot/factory_bot/badges/gpa.svg
-[grade]: https://codeclimate.com/github/thoughtbot/factory_bot
 [version-image]: https://badge.fury.io/rb/factory_bot.svg
 [version]: https://badge.fury.io/rb/factory_bot
 [hound-badge-image]: https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg

data/lib/factory_bot/attribute_assigner.rb

@@ -9,16 +9,18 @@ module FactoryBot
       @attribute_names_assigned = []
     end
 
+    # constructs an object-based factory product
     def object
       @evaluator.instance = build_class_instance
       build_class_instance.tap do |instance|
         attributes_to_set_on_instance.each do |attribute|
-          instance.public_send("#{attribute}=", get(attribute))
+          instance.public_send(:"#{attribute}=", get(attribute))
           @attribute_names_assigned << attribute
         end
       end
     end
 
+    # constructs a Hash-based factory product
     def hash
       @evaluator.instance = build_hash
 
@@ -29,6 +31,8 @@ module FactoryBot
 
     private
 
+    # Track evaluation of methods on the evaluator to prevent the duplicate
+    # assignment of attributes accessed and via `initialize_with` syntax
     def method_tracking_evaluator
       @method_tracking_evaluator ||= Decorator::AttributeHash.new(
         decorated_evaluator,
@@ -67,12 +71,15 @@ module FactoryBot
       attribute_names_to_assign - association_names
     end
 
+    # Builds a list of attributes names that should be assigned to the factory product
     def attribute_names_to_assign
-      @attribute_names_to_assign ||=
-        non_ignored_attribute_names +
-        override_names -
-        ignored_attribute_names -
-        alias_names_to_ignore
+      @attribute_names_to_assign ||= begin
+        # start a list of candidates containing non-transient attributes and overrides
+        assignment_candidates = non_ignored_attribute_names + override_names
+        # then remove any transient attributes (potentially reintroduced by the overrides),
+        # and remove ignorable aliased attributes from the candidate list
+        assignment_candidates - ignored_attribute_names - attribute_names_overriden_by_alias
+      end
     end
 
     def non_ignored_attribute_names
@@ -91,22 +98,71 @@ module FactoryBot
       @evaluator.__override_names__
     end
 
-    def hash_instance_methods_to_respond_to
-      @attribute_list.names + override_names + @build_class.instance_methods
-    end
-
-    def alias_names_to_ignore
-      @attribute_list.non_ignored.flat_map { |attribute|
-        override_names.map do |override|
-          attribute.name if ignorable_alias?(attribute, override)
-        end
-      }.compact
+    def attribute_names
+      @attribute_list.names
     end
 
+    def hash_instance_methods_to_respond_to
+      attribute_names + override_names + @build_class.instance_methods
+    end
+
+    # Builds a list of attribute names which are slated to be interrupted by an override.
+    def attribute_names_overriden_by_alias
+      @attribute_list
+        .non_ignored
+        .flat_map { |attribute|
+          override_names.map do |override|
+            attribute.name if ignorable_alias?(attribute, override)
+          end
+        }
+        .compact
+    end
+
+    # Is the attribute an ignorable alias of the override?
+    # An attribute is ignorable when it is an alias of the override AND it is
+    # either interrupting an assocciation OR is not the name of another attribute
+    #
+    # @note An "alias" is currently an overloaded term for two distinct cases:
+    #   (1) attributes which are aliases and reference the same value
+    #   (2) a logical grouping of a foreign key and an associated object
     def ignorable_alias?(attribute, override)
-      attribute.alias_for?(override) &&
-        attribute.name != override &&
-        !ignored_attribute_names.include?(override)
+      return false unless attribute.alias_for?(override)
+
+      # The attribute alias should be ignored when the override interrupts an association
+      return true if override_interrupts_association?(attribute, override)
+
+      # Remaining aliases should be ignored when the override does not match a declared attribute.
+      # An override which is an alias to a declared attribute should not interrupt the aliased
+      # attribute and interrupt only the attribute with a matching name. This workaround allows a
+      # factory to declare both <attribute> and <attribute>_id as separate and distinct attributes.
+      !override_matches_declared_attribute?(override)
+    end
+
+    # Does this override interrupt an association?
+    # When true, this indicates the aliased attribute is related to a declared association and the
+    # override does not match the attribute name.
+    #
+    # @note Association overrides should take precedence over a declared foreign key attribute.
+    #
+    # @note An override may interrupt an association by providing the associated object or
+    #   by providing the foreign key.
+    #
+    # @param [FactoryBot::Attribute] aliased_attribute
+    # @param [Symbol] override name of an override which is an alias to the attribute name
+    def override_interrupts_association?(aliased_attribute, override)
+      (aliased_attribute.association? || association_names.include?(override)) &&
+        aliased_attribute.name != override
+    end
+
+    # Does this override match the name of any declared attribute?
+    #
+    # @note Checking against the names of all attributes, resolves any issues with having both
+    #   <attribute> and <attribute>_id in the same factory. This also takes into account ignored
+    #   attributes that should not be assigned (aka transient attributes)
+    #
+    # @param [Symbol] override the name of an override
+    def override_matches_declared_attribute?(override)
+      attribute_names.include?(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/decorator.rb

@@ -6,24 +6,12 @@ module FactoryBot
       @component = component
     end
 
-    if ::Gem::Version.new(::RUBY_VERSION) >= ::Gem::Version.new("2.7")
-      class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-          def method_missing(...) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
-          @component.send(...)
-        end
-
-        def send(...)
-          __send__(...)
-        end
-      RUBY
-    else
-      def method_missing(name, *args, &block) # rubocop:disable Style/MissingRespondToMissing
-        @component.send(name, *args, &block)
-      end
+    def method_missing(...) # rubocop:disable Style/MethodMissingSuper
+      @component.send(...)
+    end
 
-      def send(symbol, *args, &block)
-        __send__(symbol, *args, &block)
-      end
+    def send(...)
+      __send__(...)
     end
 
     def respond_to_missing?(name, include_private = false)

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
@@ -95,6 +96,10 @@ module FactoryBot
       @defined_traits.add(trait)
     end
 
+    def defined_traits_names
+      @defined_traits.map(&:name)
+    end
+
     def register_enum(enum)
       @registered_enums << enum
     end

data/lib/factory_bot/definition_proxy.rb

@@ -94,7 +94,7 @@ module FactoryBot
       if association_options.nil?
         __declare_attribute__(name, block)
       elsif __valid_association_options?(association_options)
-        association(name, association_options)
+        association(name, association_options, &block)
       else
         raise NoMethodError.new(<<~MSG)
           undefined method '#{name}' in '#{@definition.name}' factory
@@ -120,9 +120,13 @@ module FactoryBot
     #
     # Except that no globally available sequence will be defined.
     def sequence(name, *args, &block)
-      sequence = Sequence.new(name, *args, &block)
-      FactoryBot::Internal.register_inline_sequence(sequence)
-      add_attribute(name) { increment_sequence(sequence) }
+      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
@@ -35,14 +34,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)
@@ -52,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,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
@@ -29,18 +33,22 @@ module FactoryBot
 
     def run(build_strategy, overrides, &block)
       block ||= ->(result) { result }
+
       compile
 
-      strategy = StrategyCalculator.new(build_strategy).strategy.new
+      strategy = Strategy.lookup_strategy(build_strategy).new
 
       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, observer)
+      evaluation = Evaluation.new(evaluator, attribute_assigner, compiled_to_create, observer)
+
+      evaluation.notify(:before_all, nil)
+      instance = strategy.result(evaluation).tap(&block)
+      evaluation.notify(:after_all, instance)
 
-      strategy.result(evaluation).tap(&block)
+      instance
     end
 
     def human_names
@@ -83,7 +91,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 +159,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/factory_runner.rb

@@ -25,6 +25,8 @@ module FactoryBot
         factory: factory
       }
 
+      ActiveSupport::Notifications.instrument("factory_bot.before_run_factory", instrumentation_payload)
+
       ActiveSupport::Notifications.instrument("factory_bot.run_factory", instrumentation_payload) do
         factory.run(runner_strategy, @overrides, &block)
       end

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/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(joinable: false) do
+          yield
+          raise ActiveRecord::Rollback
+        end
+      else
+        yield
+      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