factory_bot 5.0.2 → 6.1.0

data/lib/factory_bot/declaration/implicit.rb

@@ -23,8 +23,11 @@ module FactoryBot
       def build
         if FactoryBot.factories.registered?(name)
           [Attribute::Association.new(name, name, {})]
-        elsif FactoryBot.sequences.registered?(name)
+        elsif FactoryBot::Internal.sequences.registered?(name)
           [Attribute::Sequence.new(name, name, @ignored)]
+        elsif @factory.name.to_s == name.to_s
+          message = "Self-referencing trait '#{@name}'"
+          raise TraitDefinitionError, message
         else
           @factory.inherit_traits([name])
           []

data/lib/factory_bot/declaration_list.rb

@@ -5,8 +5,8 @@ module FactoryBot
 
     def initialize(name = nil)
       @declarations = []
-      @name         = name
-      @overridable  = false
+      @name = name
+      @overridable = false
     end
 
     def declare_attribute(declaration)

data/lib/factory_bot/decorator.rb

@@ -6,18 +6,30 @@ module FactoryBot
       @component = component
     end
 
-    def method_missing(name, *args, &block) # rubocop:disable Style/MethodMissing
-      @component.send(name, *args, &block)
+    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/MethodMissingSuper, Style/MissingRespondToMissing
+        @component.send(name, *args, &block)
+      end
+
+      def send(symbol, *args, &block)
+        __send__(symbol, *args, &block)
+      end
     end
 
     def respond_to_missing?(name, include_private = false)
       @component.respond_to?(name, true) || super
     end
 
-    def send(symbol, *args, &block)
-      __send__(symbol, *args, &block)
-    end
-
     def self.const_missing(name)
       ::Object.const_get(name)
     end

data/lib/factory_bot/decorator/invocation_tracker.rb

@@ -6,9 +6,16 @@ module FactoryBot
         @invoked_methods = []
       end
 
-      def method_missing(name, *args, &block) # rubocop:disable Style/MethodMissing
-        @invoked_methods << name
-        super
+      if ::Gem::Version.new(::RUBY_VERSION) >= ::Gem::Version.new("2.7")
+        def method_missing(name, *args, **kwargs, &block) # rubocop:disable Style/MissingRespondToMissing
+          @invoked_methods << name
+          super
+        end
+      else
+        def method_missing(name, *args, &block) # rubocop:disable Style/MissingRespondToMissing
+          @invoked_methods << name
+          super
+        end
       end
 
       def __invoked_methods__

data/lib/factory_bot/definition.rb

@@ -1,19 +1,21 @@
 module FactoryBot
   # @api private
   class Definition
-    attr_reader :defined_traits, :declarations, :name
+    attr_reader :defined_traits, :declarations, :name, :registered_enums
 
     def initialize(name, base_traits = [])
-      @name              = name
-      @declarations      = DeclarationList.new(name)
-      @callbacks         = []
-      @defined_traits    = Set.new
-      @to_create         = nil
-      @base_traits       = base_traits
+      @name = name
+      @declarations = DeclarationList.new(name)
+      @callbacks = []
+      @defined_traits = Set.new
+      @registered_enums = []
+      @to_create = nil
+      @base_traits = base_traits
       @additional_traits = []
-      @constructor       = nil
-      @attributes        = nil
-      @compiled          = false
+      @constructor = nil
+      @attributes = nil
+      @compiled = false
+      @expanded_enum_traits = false
     end
 
     delegate :declare_attribute, to: :declarations
@@ -43,13 +45,15 @@ module FactoryBot
       aggregate_from_traits_and_self(:callbacks) { @callbacks }
     end
 
-    def compile
+    def compile(klass = nil)
       unless @compiled
+        expand_enum_traits(klass) unless klass.nil?
+
         declarations.attributes
 
         defined_traits.each do |defined_trait|
-          base_traits.each       { |bt| bt.define_trait defined_trait }
-          additional_traits.each { |bt| bt.define_trait defined_trait }
+          base_traits.each { |bt| bt.define_trait defined_trait }
+          additional_traits.each { |at| at.define_trait defined_trait }
         end
 
         @compiled = true
@@ -81,6 +85,10 @@ module FactoryBot
       @defined_traits.add(trait)
     end
 
+    def register_enum(enum)
+      @registered_enums << enum
+    end
+
     def define_constructor(&block)
       @constructor = block
     end
@@ -95,7 +103,6 @@ module FactoryBot
 
     def callback(*names, &block)
       names.each do |name|
-        FactoryBot.register_callback(name)
         add_callback(Callback.new(name, block))
       end
     end
@@ -111,17 +118,19 @@ module FactoryBot
     end
 
     def trait_by_name(name)
-      trait_for(name) || FactoryBot.trait_by_name(name)
+      trait_for(name) || Internal.trait_by_name(name)
     end
 
     def trait_for(name)
-      defined_traits.detect { |trait| trait.name == name.to_s }
+      @defined_traits_by_name ||= defined_traits.each_with_object({}) { |t, memo| memo[t.name] ||= t }
+      @defined_traits_by_name[name.to_s]
     end
 
     def initialize_copy(source)
       super
       @attributes = nil
-      @compiled   = false
+      @compiled = false
+      @defined_traits_by_name = nil
     end
 
     def aggregate_from_traits_and_self(method_name, &block)
@@ -130,8 +139,32 @@ module FactoryBot
       [
         base_traits.map(&method_name),
         instance_exec(&block),
-        additional_traits.map(&method_name),
+        additional_traits.map(&method_name)
       ].flatten.compact
     end
+
+    def expand_enum_traits(klass)
+      return if @expanded_enum_traits
+
+      if automatically_register_defined_enums?(klass)
+        automatically_register_defined_enums(klass)
+      end
+
+      registered_enums.each do |enum|
+        traits = enum.build_traits(klass)
+        traits.each { |trait| define_trait(trait) }
+      end
+
+      @expanded_enum_traits = true
+    end
+
+    def automatically_register_defined_enums(klass)
+      klass.defined_enums.each_key { |name| register_enum(Enum.new(name)) }
+    end
+
+    def automatically_register_defined_enums?(klass)
+      FactoryBot.automatically_define_enum_traits &&
+        klass.respond_to?(:defined_enums)
+    end
   end
 end

data/lib/factory_bot/definition_hierarchy.rb

@@ -1,16 +1,6 @@
 module FactoryBot
   class DefinitionHierarchy
-    def callbacks
-      FactoryBot.callbacks
-    end
-
-    def constructor
-      FactoryBot.constructor
-    end
-
-    def to_create
-      FactoryBot.to_create
-    end
+    delegate :callbacks, :constructor, :to_create, to: Internal
 
     def self.build_from_definition(definition)
       build_to_create(&definition.to_create)

data/lib/factory_bot/definition_proxy.rb

@@ -1,6 +1,6 @@
 module FactoryBot
   class DefinitionProxy
-    UNPROXIED_METHODS = %w(
+    UNPROXIED_METHODS = %w[
       __send__
       __id__
       nil?
@@ -13,7 +13,7 @@ module FactoryBot
       raise
       caller
       method
-    ).freeze
+    ].freeze
 
     (instance_methods + private_instance_methods).each do |method|
       undef_method(method) unless UNPROXIED_METHODS.include?(method.to_s)
@@ -24,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
 
@@ -88,15 +88,18 @@ module FactoryBot
     #   end
     #
     # are equivalent.
-    def method_missing(name, *args, &block) # rubocop:disable Style/MethodMissing
-      if args.empty?
+    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 args.first.respond_to?(:has_key?) && args.first.has_key?(:factory)
-        association(name, *args)
+      elsif __valid_association_options?(association_options)
+        association(name, association_options)
       else
-        raise NoMethodError.new(
-          "undefined method '#{name}' in '#{@definition.name}' factory",
-        )
+        raise NoMethodError.new(<<~MSG)
+          undefined method '#{name}' in '#{@definition.name}' factory
+          Did you mean? '#{name} { #{association_options.inspect} }'
+        MSG
       end
     end
 
@@ -149,7 +152,7 @@ module FactoryBot
       if block_given?
         raise AssociationDefinitionError.new(
           "Unexpected block passed to '#{name}' association "\
-          "in '#{@definition.name}' factory",
+          "in '#{@definition.name}' factory"
         )
       else
         declaration = Declaration::Association.new(name, *options)
@@ -173,6 +176,64 @@ 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
@@ -187,5 +248,9 @@ module FactoryBot
         add_attribute(name, &block)
       end
     end
+
+    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
 

data/lib/factory_bot/evaluator.rb

@@ -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,15 +33,23 @@ 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) # rubocop:disable Style/MethodMissing
-      if @instance.respond_to?(method_name)
-        @instance.send(method_name, *args, &block)
-      else
-        SyntaxRunner.new.send(method_name, *args, &block)
+    if ::Gem::Version.new(::RUBY_VERSION) >= ::Gem::Version.new("2.7")
+      def method_missing(method_name, *args, **kwargs, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
+        if @instance.respond_to?(method_name)
+          @instance.send(method_name, *args, **kwargs, &block)
+        else
+          SyntaxRunner.new.send(method_name, *args, **kwargs, &block)
+        end
+      end
+    else
+      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
     end
 
@@ -66,7 +74,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