factory_bot 4.11.1 → 6.2.0

data/lib/factory_bot/definition_proxy.rb

@@ -1,6 +1,19 @@
 module FactoryBot
   class DefinitionProxy
-    UNPROXIED_METHODS = %w(__send__ __id__ nil? send object_id extend instance_eval initialize block_given? raise caller method)
+    UNPROXIED_METHODS = %w[
+      __send__
+      __id__
+      nil?
+      send
+      object_id
+      extend
+      instance_eval
+      initialize
+      block_given?
+      raise
+      caller
+      method
+    ].freeze
 
     (instance_methods + private_instance_methods).each do |method|
       undef_method(method) unless UNPROXIED_METHODS.include?(method.to_s)
@@ -11,8 +24,8 @@ module FactoryBot
     attr_reader :child_factories
 
     def initialize(definition, ignore = false)
-      @definition      = definition
-      @ignore          = ignore
+      @definition = definition
+      @ignore = ignore
       @child_factories = []
     end
 
@@ -21,43 +34,21 @@ module FactoryBot
       raise FactoryBot::MethodDefinitionError, message
     end
 
-    # Adds an attribute that should be assigned on generated instances for this
-    # factory.
-    #
-    # This method should be called with either a value or block, but not both. If
-    # called with a block, the attribute will be generated "lazily," whenever an
-    # instance is generated. Lazy attribute blocks will not be called if that
+    # Adds an attribute to the factory.
+    # The attribute value will be generated "lazily"
+    # by calling the block whenever an instance is generated.
+    # The block will not be called if the
     # attribute is overridden for a specific instance.
     #
-    # When defining lazy attributes, an instance of FactoryBot::Strategy will
-    # be yielded, allowing associations to be built using the correct build
-    # strategy.
-    #
     # Arguments:
     # * name: +Symbol+ or +String+
     #   The name of this attribute. This will be assigned using "name=" for
     #   generated instances.
-    # * value: +Object+
-    #   If no block is given, this value will be used for this attribute.
-    def add_attribute(name, value = nil, &block)
-      raise AttributeDefinitionError, 'Both value and block given' if value && block_given?
-
-      declaration = if block_given?
-        Declaration::Dynamic.new(name, @ignore, block)
-      else
-        warn_static_attribute_deprecation(name, value)
-        Declaration::Static.new(name, value, @ignore)
-      end
-
+    def add_attribute(name, &block)
+      declaration = Declaration::Dynamic.new(name, @ignore, block)
       @definition.declare_attribute(declaration)
     end
 
-    def ignore(&block)
-      ActiveSupport::Deprecation.warn "`#ignore` is deprecated and will be "\
-        "removed in 5.0. Please use `#transient` instead."
-      transient(&block)
-    end
-
     def transient(&block)
       proxy = DefinitionProxy.new(@definition, true)
       proxy.instance_eval(&block)
@@ -67,40 +58,48 @@ module FactoryBot
     # attribute, so that:
     #
     #   factory :user do
-    #     name 'Billy Idol'
+    #     name { 'Billy Idol' }
     #   end
     #
     # and:
     #
     #   factory :user do
-    #     add_attribute :name, 'Billy Idol'
+    #     add_attribute(:name) { 'Billy Idol' }
     #   end
     #
     # are equivalent.
     #
-    # If no argument or block is given, factory_bot will look for a sequence
-    # or association with the same name. This means that:
+    # If no argument or block is given, factory_bot will first look for an
+    # association, then for a sequence, and finally for a trait with the same
+    # name. This means that given an "admin" trait, an "email" sequence, and an
+    # "account" factory:
     #
-    #   factory :user do
-    #     email { create(:email) }
+    #   factory :user, traits: [:admin] do
+    #     email { generate(:email) }
     #     association :account
     #   end
     #
     # and:
     #
     #   factory :user do
+    #     admin
     #     email
     #     account
     #   end
     #
     # are equivalent.
-    def method_missing(name, *args, &block)
-      if args.empty? && block.nil?
-        @definition.declare_attribute(Declaration::Implicit.new(name, @definition, @ignore))
-      elsif args.first.respond_to?(:has_key?) && args.first.has_key?(:factory)
-        association(name, *args)
+    def method_missing(name, *args, &block) # rubocop:disable Style/MissingRespondToMissing, Style/MethodMissingSuper
+      association_options = args.first
+
+      if association_options.nil?
+        __declare_attribute__(name, block)
+      elsif __valid_association_options?(association_options)
+        association(name, association_options)
       else
-        add_attribute(name, *args, &block)
+        raise NoMethodError.new(<<~MSG)
+          undefined method '#{name}' in '#{@definition.name}' factory
+          Did you mean? '#{name} { #{association_options.inspect} }'
+        MSG
       end
     end
 
@@ -122,6 +121,7 @@ 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) }
     end
 
@@ -149,7 +149,15 @@ module FactoryBot
     #    name of the factory. For example, a "user" association will by
     #    default use the "user" factory.
     def association(name, *options)
-      @definition.declare_attribute(Declaration::Association.new(name, *options))
+      if block_given?
+        raise AssociationDefinitionError.new(
+          "Unexpected block passed to '#{name}' association "\
+          "in '#{@definition.name}' factory"
+        )
+      else
+        declaration = Declaration::Association.new(name, *options)
+        @definition.declare_attribute(declaration)
+      end
     end
 
     def to_create(&block)
@@ -168,34 +176,81 @@ module FactoryBot
       @definition.define_trait(Trait.new(name, &block))
     end
 
+    # Creates traits for enumerable values.
+    #
+    # Example:
+    #   factory :task do
+    #     traits_for_enum :status, [:started, :finished]
+    #   end
+    #
+    # Equivalent to:
+    #   factory :task do
+    #     trait :started do
+    #       status { :started }
+    #     end
+    #
+    #     trait :finished do
+    #       status { :finished }
+    #     end
+    #   end
+    #
+    # Example:
+    #   factory :task do
+    #     traits_for_enum :status, {started: 1, finished: 2}
+    #   end
+    #
+    # Example:
+    #   class Task
+    #     def statuses
+    #       {started: 1, finished: 2}
+    #     end
+    #   end
+    #
+    #   factory :task do
+    #     traits_for_enum :status
+    #   end
+    #
+    # Both equivalent to:
+    #   factory :task do
+    #     trait :started do
+    #       status { 1 }
+    #     end
+    #
+    #     trait :finished do
+    #       status { 2 }
+    #     end
+    #   end
+    #
+    #
+    # Arguments:
+    #   attribute_name: +Symbol+ or +String+
+    #     the name of the attribute these traits will set the value of
+    #   values: +Array+, +Hash+, or other +Enumerable+
+    #     An array of trait names, or a mapping of trait names to values for
+    #     those traits. When this argument is not provided, factory_bot will
+    #     attempt to get the values by calling the pluralized `attribute_name`
+    #     class method.
+    def traits_for_enum(attribute_name, values = nil)
+      @definition.register_enum(Enum.new(attribute_name, values))
+    end
+
     def initialize_with(&block)
       @definition.define_constructor(&block)
     end
 
     private
 
-    def warn_static_attribute_deprecation(name, value)
-      attribute_caller = caller(2)
-
-      if attribute_caller[0].include?("method_missing")
-        attribute_caller = caller(3)
+    def __declare_attribute__(name, block)
+      if block.nil?
+        declaration = Declaration::Implicit.new(name, @definition, @ignore)
+        @definition.declare_attribute(declaration)
+      else
+        add_attribute(name, &block)
       end
+    end
 
-      ActiveSupport::Deprecation.warn(<<-MSG, attribute_caller)
-Static attributes will be removed in FactoryBot 5.0. Please use dynamic
-attributes instead by wrapping the attribute value in a block:
-
-#{name} { #{value.inspect} }
-
-To automatically update from static attributes to dynamic ones,
-install rubocop-rspec and run:
-
-rubocop \\
-  --require rubocop-rspec \\
-  --only FactoryBot/AttributeDefinedStatically \\
-  --auto-correct
-
-      MSG
+    def __valid_association_options?(options)
+      options.respond_to?(:has_key?) && options.has_key?(:factory)
     end
   end
 end

data/lib/factory_bot/enum.rb

@@ -0,0 +1,27 @@
+module FactoryBot
+  # @api private
+  class Enum
+    def initialize(attribute_name, values = nil)
+      @attribute_name = attribute_name
+      @values = values
+    end
+
+    def build_traits(klass)
+      enum_values(klass).map do |trait_name, value|
+        build_trait(trait_name, @attribute_name, value || trait_name)
+      end
+    end
+
+    private
+
+    def enum_values(klass)
+      @values || klass.send(@attribute_name.to_s.pluralize)
+    end
+
+    def build_trait(trait_name, attribute_name, value)
+      Trait.new(trait_name) do
+        add_attribute(attribute_name) { value }
+      end
+    end
+  end
+end

data/lib/factory_bot/errors.rb

@@ -2,6 +2,9 @@ module FactoryBot
   # Raised when a factory is defined that attempts to instantiate itself.
   class AssociationDefinitionError < RuntimeError; end
 
+  # Raised when a trait is defined that references itself.
+  class TraitDefinitionError < RuntimeError; end
+
   # Raised when a callback is defined that has an invalid name
   class InvalidCallbackNameError < RuntimeError; end
 
@@ -11,12 +14,12 @@ module FactoryBot
   # Raised when attempting to register a sequence from a dynamic attribute block
   class SequenceAbuseError < RuntimeError; end
 
-  # Raised when defining an invalid attribute:
-  # * Defining an attribute which has a name ending in "="
-  # * Defining an attribute with both a static and lazy value
-  # * Defining an attribute twice in the same factory
+  # Raised when defining an attribute twice in the same factory
   class AttributeDefinitionError < RuntimeError; end
 
+  # Raised when attempting to pass a block to an association definition
+  class AssociationDefinitionError < RuntimeError; end
+
   # Raised when a method is defined in a factory or trait with arguments
   class MethodDefinitionError < RuntimeError; end
 

data/lib/factory_bot/evaluation.rb

@@ -1,4 +1,4 @@
-require 'observer'
+require "observer"
 
 module FactoryBot
   class Evaluation

data/lib/factory_bot/evaluator.rb

@@ -1,5 +1,5 @@
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/class/attribute'
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/class/attribute"
 
 module FactoryBot
   # @api private
@@ -7,7 +7,7 @@ module FactoryBot
     class_attribute :attribute_lists
 
     private_instance_methods.each do |method|
-      undef_method(method) unless method =~ /^__|initialize/
+      undef_method(method) unless method.match?(/^__|initialize/)
     end
 
     def initialize(build_strategy, overrides = {})
@@ -23,9 +23,9 @@ module FactoryBot
 
     def association(factory_name, *traits_and_overrides)
       overrides = traits_and_overrides.extract_options!
-      strategy_override = overrides.fetch(:strategy) do
+      strategy_override = overrides.fetch(:strategy) {
         FactoryBot.use_parent_strategy ? @build_strategy.class : :create
-      end
+      }
 
       traits_and_overrides += [overrides.except(:strategy)]
 
@@ -33,19 +33,18 @@ module FactoryBot
       @build_strategy.association(runner)
     end
 
-    def instance=(object_instance)
-      @instance = object_instance
-    end
+    attr_accessor :instance
 
-    def method_missing(method_name, *args, &block)
+    def method_missing(method_name, *args, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
       if @instance.respond_to?(method_name)
         @instance.send(method_name, *args, &block)
       else
         SyntaxRunner.new.send(method_name, *args, &block)
       end
     end
+    ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
 
-    def respond_to_missing?(method_name, include_private = false)
+    def respond_to_missing?(method_name, _include_private = false)
       @instance.respond_to?(method_name) || SyntaxRunner.new.respond_to?(method_name)
     end
 
@@ -66,7 +65,7 @@ module FactoryBot
     end
 
     def self.define_attribute(name, &block)
-      if method_defined?(name) || private_method_defined?(name)
+      if instance_methods(false).include?(name) || private_instance_methods(false).include?(name)
         undef_method(name)
       end
 

data/lib/factory_bot/evaluator_class_definer.rb

@@ -3,7 +3,7 @@ module FactoryBot
   class EvaluatorClassDefiner
     def initialize(attributes, parent_class)
       @parent_class = parent_class
-      @attributes   = attributes
+      @attributes = attributes
 
       attributes.each do |attribute|
         evaluator_class.define_attribute(attribute.name, &attribute.to_proc)

data/lib/factory_bot/factory.rb

@@ -1,5 +1,5 @@
-require 'active_support/core_ext/hash/keys'
-require 'active_support/inflector'
+require "active_support/core_ext/hash/keys"
+require "active_support/inflector"
 
 module FactoryBot
   # @api private
@@ -8,16 +8,16 @@ module FactoryBot
 
     def initialize(name, options = {})
       assert_valid_options(options)
-      @name             = name.respond_to?(:to_sym) ? name.to_sym : name.to_s.underscore.to_sym
-      @parent           = options[:parent]
-      @aliases          = options[:aliases] || []
-      @class_name       = options[:class]
-      @definition       = Definition.new(@name, options[:traits] || [])
-      @compiled         = false
+      @name = name.respond_to?(:to_sym) ? name.to_sym : name.to_s.underscore.to_sym
+      @parent = options[:parent]
+      @aliases = options[:aliases] || []
+      @class_name = options[:class]
+      @definition = Definition.new(@name, options[:traits] || [])
+      @compiled = false
     end
 
     delegate :add_callback, :declare_attribute, :to_create, :define_trait, :constructor,
-             :defined_traits, :inherit_traits, :append_traits, to: :@definition
+      :defined_traits, :inherit_traits, :append_traits, to: :@definition
 
     def build_class
       @build_class ||= if class_name.is_a? Class
@@ -84,14 +84,14 @@ module FactoryBot
       unless @compiled
         parent.compile
         parent.defined_traits.each { |trait| define_trait(trait) }
-        @definition.compile
+        @definition.compile(build_class)
         build_hierarchy
         @compiled = true
       end
     end
 
     def with_traits(traits)
-      self.clone.tap do |factory_with_traits|
+      clone.tap do |factory_with_traits|
         factory_with_traits.append_traits traits
       end
     end
@@ -145,7 +145,7 @@ module FactoryBot
 
     def parent
       if @parent
-        FactoryBot.factory_by_name(@parent)
+        FactoryBot::Internal.factory_by_name(@parent)
       else
         NullFactory.new
       end

data/lib/factory_bot/factory_runner.rb

@@ -1,15 +1,15 @@
 module FactoryBot
   class FactoryRunner
     def initialize(name, strategy, traits_and_overrides)
-      @name     = name
+      @name = name
       @strategy = strategy
 
       @overrides = traits_and_overrides.extract_options!
-      @traits    = traits_and_overrides
+      @traits = traits_and_overrides
     end
 
     def run(runner_strategy = @strategy, &block)
-      factory = FactoryBot.factory_by_name(@name)
+      factory = FactoryBot::Internal.factory_by_name(@name)
 
       factory.compile
 
@@ -25,7 +25,7 @@ module FactoryBot
         factory: factory
       }
 
-      ActiveSupport::Notifications.instrument('factory_bot.run_factory', instrumentation_payload) do
+      ActiveSupport::Notifications.instrument("factory_bot.run_factory", instrumentation_payload) do
         factory.run(runner_strategy, @overrides, &block)
       end
     end

data/lib/factory_bot/find_definitions.rb

@@ -7,7 +7,7 @@ module FactoryBot
     attr_accessor :definition_file_paths
   end
 
-  self.definition_file_paths = %w(factories test/factories spec/factories)
+  self.definition_file_paths = %w[factories test/factories spec/factories]
 
   def self.find_definitions
     absolute_definition_file_paths = definition_file_paths.map { |path| File.expand_path(path) }
@@ -16,7 +16,7 @@ module FactoryBot
       load("#{path}.rb") if File.exist?("#{path}.rb")
 
       if File.directory? path
-        Dir[File.join(path, '**', '*.rb')].sort.each do |file|
+        Dir[File.join(path, "**", "*.rb")].sort.each do |file|
           load file
         end
       end

data/lib/factory_bot/internal.rb

@@ -0,0 +1,91 @@
+module FactoryBot
+  # @api private
+  module Internal
+    class << self
+      delegate :after,
+        :before,
+        :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
+    end
+  end
+end