Allow inline sequences in traits to have same name

Fixes #1257

When sequence rewinding was first introduced in #1078 it only applied to
globally defined sequences. To get rewinding to work for inline
sequences as well we registered them "privately" in the global registry
in #1164. Unfortunately in #1164 we did not take inline sequences inside
traits into consideration. Since trait names are not unique, it is
possibly to get a `FactoryBot::DuplicateDefinitionError` when defining
two sequences that have the same name in two traits that have the same
name.

This PR abandons the idea of "privately" registering inline sequences,
and instead keeps a separate list of all the inline sequences just for
the purpose of rewinding them.

The downside here is that we are adding another public method to
FactoryBot. But I think it is similar enough to the other `register_`
methods, which are technically public but are left undocumented and not
really treated as part of the FactoryBot API.

Author: composerinteralia

lib/factory_bot.rb

@@ -75,6 +75,7 @@ def self.lint(*args)
 
   class << self
     delegate :factories,
+             :inline_sequences,
              :sequences,
              :traits,
              :callbacks,
@@ -108,12 +109,17 @@ def self.register_sequence(sequence)
     sequence
   end
 
+  def self.register_inline_sequence(sequence)
+    inline_sequences.push(sequence)
+  end
+
   def self.sequence_by_name(name)
     sequences.find(name)
   end
 
   def self.rewind_sequences
     sequences.each(&:rewind)
+    inline_sequences.each(&:rewind)
   end
 
   def self.register_trait(trait)

lib/factory_bot/configuration.rb

@@ -1,7 +1,14 @@
 module FactoryBot
   # @api private
   class Configuration
-    attr_reader :factories, :sequences, :traits, :strategies, :callback_names
+    attr_reader(
+      :callback_names,
+      :factories,
+      :inline_sequences,
+      :sequences,
+      :strategies,
+      :traits,
+    )
 
     def initialize
       @factories      = Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Factory"))
@@ -10,6 +17,7 @@ def initialize
       @strategies     = Registry.new("Strategy")
       @callback_names = Set.new
       @definition     = Definition.new(:configuration)
+      @inline_sequences = []
 
       to_create(&:save!)
       initialize_with { new }

lib/factory_bot/definition_proxy.rb

@@ -117,9 +117,8 @@ def method_missing(name, *args, &block) # rubocop:disable Style/MethodMissing
     #
     # Except that no globally available sequence will be defined.
     def sequence(name, *args, &block)
-      sequence_name = "__#{@definition.name}_#{name}__"
-      sequence = Sequence.new(sequence_name, *args, &block)
-      FactoryBot.register_sequence(sequence)
+      sequence = Sequence.new(name, *args, &block)
+      FactoryBot.register_inline_sequence(sequence)
       add_attribute(name) { increment_sequence(sequence) }
     end
 

spec/acceptance/sequence_resetting_spec.rb

@@ -90,4 +90,34 @@
     expect(user.email).to eq "[email protected]"
     expect(email).to eq "[email protected]"
   end
+
+  it "allows setting sequences within identically named traits" do
+    define_class("User") { attr_accessor :email }
+    define_class("Person") { attr_accessor :email }
+
+    FactoryBot.define do
+      factory :user do
+        trait :with_email do
+          sequence(:email) { |n| "user#{n}@example.com" }
+        end
+      end
+
+      factory :person do
+        trait :with_email do
+          sequence(:email) { |n| "person#{n}@example.com" }
+        end
+      end
+    end
+
+    build_list(:user, 2, :with_email)
+    build_list(:person, 2, :with_email)
+
+    FactoryBot.rewind_sequences
+
+    user = build(:user, :with_email)
+    person = build(:person, :with_email)
+
+    expect(user.email).to eq "[email protected]"
+    expect(person.email).to eq "[email protected]"
+  end
 end

spec/factory_bot/definition_proxy_spec.rb

@@ -106,18 +106,20 @@ def build_proxy(factory_name)
 
   it "creates a new sequence starting at 1" do
     proxy = build_proxy(:factory)
+
     proxy.sequence(:sequence)
 
-    expect(FactoryBot::Sequence).to have_received(:new).
-      with("__factory_sequence__")
+    expect(FactoryBot::Sequence).to have_received(:new).with(:sequence)
   end
 
   it "creates a new sequence with an overridden starting vaue" do
     proxy = build_proxy(:factory)
-    proxy.sequence(:sequence, "C")
+    override = "override"
+
+    proxy.sequence(:sequence, override)
 
     expect(FactoryBot::Sequence).to have_received(:new).
-      with("__factory_sequence__", "C")
+      with(:sequence, override)
   end
 
   it "creates a new sequence with a block" do