Use a registry class for keeping factories and sequences. Treat

sequences largely like factories. Refactor name and aliases into a
common names method.

lib/factory_girl.rb

@@ -3,6 +3,7 @@ require 'factory_girl/proxy/build'
 require 'factory_girl/proxy/create'
 require 'factory_girl/proxy/attributes_for'
 require 'factory_girl/proxy/stub'
+require 'factory_girl/registry'
 require 'factory_girl/factory'
 require 'factory_girl/attribute'
 require 'factory_girl/attribute/static'

lib/factory_girl/definition_proxy.rb

@@ -59,7 +59,7 @@ module FactoryGirl
     # or association with the same name. This means that:
     #
     #   factory :user do
-    #     email { Factory.next(:email) }
+    #     email { create(:email) }
     #     association :account
     #   end
     #
@@ -73,11 +73,7 @@ module FactoryGirl
     # are equivilent.
     def method_missing(name, *args, &block)
       if args.empty? && block.nil?
-        if sequence = FactoryGirl.sequences[name]
-          add_attribute(name) { sequence.next }
-        else
-          association(name)
-        end
+        association(name)
       else
         add_attribute(name, *args, &block)
       end
@@ -95,13 +91,13 @@ module FactoryGirl
     #   sequence(:email) { |n| "person#{n}@example.com" }
     #
     #   factory :user do
-    #     email { Factory.next(:email) }
+    #     email { FactoryGirl.create(:email) }
     #   end
     #
     # Except that no globally available sequence will be defined.
     def sequence(name, start_value = 1, &block)
-      sequence = Sequence.new(start_value, &block)
-      add_attribute(name) { sequence.next }
+      sequence = Sequence.new(name, start_value, &block)
+      add_attribute(name) { sequence.run }
     end
 
     # Adds an attribute that builds an association. The associated instance will

lib/factory_girl/factory.rb

@@ -1,29 +1,14 @@
 module FactoryGirl
-  class << self
-    attr_accessor :factories #:nodoc:
+  def self.factories
+    puts "WARNING: FactoryGirl.factories is deprecated."
+    puts "Use FactoryGirl.registry instead."
+    registry
   end
 
-  self.factories = {}
-
   def self.factory_by_name(name)
-    factories[name.to_sym] or raise ArgumentError.new("No such factory: #{name.to_s}")
-  end
-
-  def self.register_factory(factory, options = {})
-    if options[:as]
-      name = options[:as]
-    else
-      name = factory.name
-      factory.aliases.each do |alias_name|
-        register_factory(factory, :as => alias_name)
-      end
-    end
-
-    if self.factories[name]
-      raise DuplicateDefinitionError, "Factory already defined: #{name}"
-    end
-
-    self.factories[name] = factory
+    puts "WARNING: FactoryGirl.factory_by_name is deprecated."
+    puts "Use FactoryGirl.find instead."
+    registry.find(name)
   end
 
   # Raised when a factory is defined that attempts to instantiate itself.
@@ -119,7 +104,7 @@ module FactoryGirl
       attributes.select {|attribute| attribute.is_a?(Attribute::Association) }
     end
 
-    # Alternate names for this factory.
+    # Names for this factory, including aliases.
     #
     # Example:
     #
@@ -144,8 +129,8 @@ module FactoryGirl
     #
     #   FactoryGirl.create(:post).author.class
     #   # => User
-    def aliases
-      @options[:aliases] || []
+    def names
+      [name] + (@options[:aliases] || [])
     end
 
     def to_create(&block)

lib/factory_girl/proxy/build.rb

@@ -14,12 +14,12 @@ module FactoryGirl
       end
 
       def associate(name, factory_name, overrides)
-        factory = FactoryGirl.factory_by_name(factory_name)
+        factory = FactoryGirl.find(factory_name)
         set(name, factory.run(Proxy::Create, overrides))
       end
 
       def association(factory_name, overrides = {})
-        factory = FactoryGirl.factory_by_name(factory_name)
+        factory = FactoryGirl.find(factory_name)
         factory.run(Proxy::Create, overrides)
       end
 

lib/factory_girl/proxy/stub.rb

@@ -46,12 +46,12 @@ module FactoryGirl
       end
 
       def associate(name, factory_name, overrides)
-        factory = FactoryGirl.factory_by_name(factory_name)
+        factory = FactoryGirl.find(factory_name)
         set(name, factory.run(Proxy::Stub, overrides))
       end
 
       def association(factory_name, overrides = {})
-        factory = FactoryGirl.factory_by_name(factory_name)
+        factory = FactoryGirl.find(factory_name)
         factory.run(Proxy::Stub, overrides)
       end
 

lib/factory_girl/registry.rb

@@ -0,0 +1,59 @@
+module FactoryGirl
+  class Registry
+    def initialize
+      @items = {}
+    end
+
+    def add(item)
+      item.names.each { |name| add_as(name, item) }
+      item
+    end
+
+    def find(name)
+      @items[name.to_sym] or raise ArgumentError.new("Not registered: #{name.to_s}")
+    end
+
+    def each(&block)
+      @items.each(&block)
+    end
+
+    def [](name)
+      find(name)
+    end
+
+    def registered?(name)
+      @items.key?(name.to_sym)
+    end
+
+    private
+
+    def add_as(name, item)
+      if registered?(name)
+        raise DuplicateDefinitionError, "Already defined: #{name}"
+      else
+        @items[name.to_sym] = item
+      end
+    end
+  end
+
+  def self.register(item)
+    registry.add(item)
+  end
+
+  def self.registered?(name)
+    registry.registered?(name)
+  end
+
+  def self.find(name)
+    registry.find(name)
+  end
+
+  def self.registry
+    @registry ||= Registry.new
+  end
+
+  def self.registry=(registry)
+    @registry = registry
+  end
+end
+

lib/factory_girl/sequence.rb

@@ -6,23 +6,37 @@ module FactoryGirl
   # Sequences are defined using sequence within a FactoryGirl.define block.
   # Sequence values are generated using next.
   class Sequence
-
-    def initialize(value = 1, &proc) #:nodoc:
+    def initialize(name, value = 1, &proc) #:nodoc:
+      @name = name
       @proc  = proc
       @value = value || 1
     end
 
     # Returns the next value for this sequence
-    def next
+    def run(proxy_class = nil, overrides = {})
       @proc ? @proc.call(@value) : @value
     ensure
       @value = @value.next
     end
 
+    def next
+      puts "WARNING: FactoryGirl::Sequence#next is deprecated."
+      puts "Use #run instead."
+      run
+    end
+
+    def default_strategy
+      :create
+    end
+
+    def names
+      [@name]
+    end
   end
 
-  class << self
-    attr_accessor :sequences #:nodoc:
+  def self.sequences
+    puts "WARNING: FactoryGirl.sequences is deprecated."
+    puts "Use FactoryGirl.registry instead."
+    registry
   end
-  self.sequences = {}
 end

lib/factory_girl/step_definitions.rb

@@ -3,7 +3,7 @@ module FactoryGirlStepHelpers
   def convert_association_string_to_instance(factory_name, assignment)
     attribute, value = assignment.split(':', 2)
     return if value.blank?
-    factory = FactoryGirl.factory_by_name(factory_name)
+    factory = FactoryGirl.find(factory_name)
     attributes = convert_human_hash_to_attribute_hash({attribute => value.strip}, factory.associations)
     attributes_find = {}
     attributes.each do |k, v|
@@ -28,7 +28,7 @@ end
 
 World(FactoryGirlStepHelpers)
 
-FactoryGirl.factories.values.each do |factory|
+FactoryGirl.registry.each do |name, factory|
   Given /^the following (?:#{factory.human_name}|#{factory.human_name.pluralize}) exists?:$/ do |table|
     table.hashes.each do |human_hash|
       attributes = convert_human_hash_to_attribute_hash(human_hash, factory.associations)

lib/factory_girl/syntax/blueprint.rb

@@ -29,7 +29,7 @@ module FactoryGirl
             instance = Factory.new(name.underscore, :class => self)
             proxy = FactoryGirl::DefinitionProxy.new(instance)
             proxy.instance_eval(&block)
-            FactoryGirl.register_factory(instance)
+            FactoryGirl.register(instance)
           end
 
         end

lib/factory_girl/syntax/default.rb

@@ -17,13 +17,13 @@ module FactoryGirl
           proxy = FactoryGirl::DefinitionProxy.new(factory)
           proxy.instance_eval(&block)
           if parent = options.delete(:parent)
-            factory.inherit_from(FactoryGirl.factory_by_name(parent))
+            factory.inherit_from(FactoryGirl.find(parent))
           end
-          FactoryGirl.register_factory(factory)
+          FactoryGirl.register(factory)
         end
 
         def sequence(name, start_value = 1, &block)
-          FactoryGirl.sequences[name] = Sequence.new(start_value, &block)
+          FactoryGirl.register(Sequence.new(name, start_value, &block))
         end
       end
     end

lib/factory_girl/syntax/generate.rb

@@ -42,7 +42,7 @@ module FactoryGirl
         module ClassMethods #:nodoc:
 
           def generate(overrides = {}, &block)
-            factory = FactoryGirl.factory_by_name(name.underscore)
+            factory = FactoryGirl.find(name.underscore)
             instance = factory.run(Proxy::Build, overrides)
             instance.save
             yield(instance) if block_given?
@@ -50,14 +50,14 @@ module FactoryGirl
           end
 
           def generate!(overrides = {}, &block)
-            factory = FactoryGirl.factory_by_name(name.underscore)
+            factory = FactoryGirl.find(name.underscore)
             instance = factory.run(Proxy::Create, overrides)
             yield(instance) if block_given?
             instance
           end
 
           def spawn(overrides = {}, &block)
-            factory = FactoryGirl.factory_by_name(name.underscore)
+            factory = FactoryGirl.find(name.underscore)
             instance = factory.run(Proxy::Build, overrides)
             yield(instance) if block_given?
             instance

lib/factory_girl/syntax/make.rb

@@ -28,7 +28,7 @@ module FactoryGirl
         module ClassMethods #:nodoc:
 
           def make(overrides = {})
-            FactoryGirl.factory_by_name(name.underscore).run(Proxy::Create, overrides)
+            FactoryGirl.find(name.underscore).run(Proxy::Create, overrides)
           end
 
         end

lib/factory_girl/syntax/methods.rb

@@ -15,7 +15,7 @@ module FactoryGirl
       # A set of attributes that can be used to build an instance of the class
       # this factory generates.
       def attributes_for(name, overrides = {})
-        FactoryGirl.factory_by_name(name).run(Proxy::AttributesFor, overrides)
+        FactoryGirl.find(name).run(Proxy::AttributesFor, overrides)
       end
 
       # Generates and returns an instance from this factory. Attributes can be
@@ -31,7 +31,7 @@ module FactoryGirl
       # An instance of the class this factory generates, with generated attributes
       # assigned.
       def build(name, overrides = {})
-        FactoryGirl.factory_by_name(name).run(Proxy::Build, overrides)
+        FactoryGirl.find(name).run(Proxy::Build, overrides)
       end
 
       # Generates, saves, and returns an instance from this factory. Attributes can
@@ -51,7 +51,7 @@ module FactoryGirl
       # A saved instance of the class this factory generates, with generated
       # attributes assigned.
       def create(name, overrides = {})
-        FactoryGirl.factory_by_name(name).run(Proxy::Create, overrides)
+        FactoryGirl.find(name).run(Proxy::Create, overrides)
       end
 
       # Generates and returns an object with all attributes from this factory
@@ -67,7 +67,7 @@ module FactoryGirl
       # Returns: +Object+
       # An object with generated attributes stubbed out.
       def build_stubbed(name, overrides = {})
-        FactoryGirl.factory_by_name(name).run(Proxy::Stub, overrides)
+        FactoryGirl.find(name).run(Proxy::Stub, overrides)
       end
 
     end

lib/factory_girl/syntax/sham.rb

@@ -27,9 +27,9 @@ module FactoryGirl
         def self.method_missing(name, *args, &block)
           if block_given?
             start_value = args.first
-            FactoryGirl.sequences[name] = Sequence.new(start_value || 1, &block)
+            FactoryGirl.register(Sequence.new(name, start_value || 1, &block))
           else
-            FactoryGirl.sequences[name].next
+            FactoryGirl.find(name).run
           end
         end
 

lib/factory_girl/syntax/vintage.rb

@@ -31,9 +31,9 @@ module FactoryGirl
           proxy = FactoryGirl::DefinitionProxy.new(factory)
           yield(proxy)
           if parent = options.delete(:parent)
-            factory.inherit_from(FactoryGirl.factory_by_name(parent))
+            factory.inherit_from(FactoryGirl.find(parent))
           end
-          FactoryGirl.register_factory(factory)
+          FactoryGirl.register(factory)
         end
 
         # Executes the default strategy for the given factory. This is usually create,
@@ -48,7 +48,7 @@ module FactoryGirl
         # Returns: +Object+
         # The result of the default strategy.
         def self.default_strategy(name, overrides = {})
-          self.send(FactoryGirl.factory_by_name(name).default_strategy, name, overrides)
+          self.send(FactoryGirl.find(name).default_strategy, name, overrides)
         end
 
         # Defines a new sequence that can be used to generate unique values in a specific format.
@@ -67,7 +67,7 @@ module FactoryGirl
         #
         #   Factory.sequence(:email) {|n| "somebody_#{n}@example.com" }
         def self.sequence(name, start_value = 1, &block)
-          FactoryGirl.sequences[name] = Sequence.new(start_value, &block)
+          FactoryGirl.register(Sequence.new(name, start_value, &block))
         end
 
         # Generates and returns the next value in a sequence.
@@ -76,14 +76,12 @@ module FactoryGirl
         #   name: (Symbol)
         #     The name of the sequence that a value should be generated for.
         #
+        # DEPRECATED. Use create instead.
+        #
         # Returns:
         #   The next value in the sequence. (Object)
-        def self.next(sequence)
-          unless FactoryGirl.sequences.key?(sequence)
-            raise "No such sequence: #{sequence}"
-          end
-
-          FactoryGirl.sequences[sequence].next
+        def self.next(name)
+          FactoryGirl.find(name).next
         end
 
         # Defines a new alias for attributes.

spec/acceptance/sequence_spec.rb

@@ -9,21 +9,21 @@ describe "sequences" do
       end
     end
 
-    first_value = Factory.next(:email)
-    another_value = Factory.next(:email)
+    first_value = FactoryGirl.create(:email)
+    another_value = FactoryGirl.create(:email)
 
     first_value.should =~ /^somebody\d+@example\.com$/
     another_value.should =~ /^somebody\d+@example\.com$/
     first_value.should_not == another_value
   end
-  
+
   it "generates sequential numbers if no block is given" do
     FactoryGirl.define do
       sequence :order
     end
 
-    first_value = Factory.next(:order)
-    another_value = Factory.next(:order)
+    first_value = FactoryGirl.create(:order)
+    another_value = FactoryGirl.create(:order)
 
     first_value.should == 1
     another_value.should == 2

spec/acceptance/syntax/blueprint_spec.rb

@@ -9,9 +9,9 @@ describe "a blueprint" do
 
     Factory.sequence(:email) { |n| "somebody#{n}@example.com" }
     User.blueprint do
-      first_name { 'Bill'               }
-      last_name  { 'Nye'                }
-      email      { Factory.next(:email) }
+      first_name { 'Bill'                     }
+      last_name  { 'Nye'                      }
+      email      { FactoryGirl.create(:email) }
     end
   end
 

spec/acceptance/syntax/sham_spec.rb

@@ -12,14 +12,14 @@ describe "a factory using sham syntax" do
 
     Sham.name        { "Name" }
     Sham.email       { "somebody#{rand(5)}@example.com" }
-    Sham.user("FOO") { |c| "User-#{c}" }
+    Sham.username("FOO") { |c| "User-#{c}" }
 
     FactoryGirl.define do
       factory :user do
         first_name { Sham.name }
         last_name  { Sham.name }
         email      { Sham.email }
-        username   { Sham.user }
+        username   { Sham.username }
       end
     end
   end

spec/acceptance/syntax/vintage_spec.rb

@@ -11,7 +11,7 @@ describe "vintage syntax" do
     Factory.define :user do |factory|
       factory.first_name { 'Bill'               }
       factory.last_name  { 'Nye'                }
-      factory.email      { Factory.next(:email) }
+      factory.email      { Factory(:email) }
     end
   end
 
@@ -37,8 +37,8 @@ describe "vintage syntax" do
   end
 
   it "should raise Factory::SequenceAbuseError" do
-    Factory.define :sequence_abuser, :class => Object do |factory|
-      factory.first_name { Factory.sequence(:email) }
+    Factory.define :sequence_abuser, :class => User do |factory|
+      factory.first_name { Factory.sequence(:name) }
     end
 
     lambda {
@@ -51,7 +51,7 @@ describe Factory, "given a parent factory" do
   before do
     @parent = FactoryGirl::Factory.new(:object)
     @parent.define_attribute(FactoryGirl::Attribute::Static.new(:name, 'value'))
-    FactoryGirl.register_factory(@parent)
+    FactoryGirl.register(@parent)
   end
 
   it "should raise an ArgumentError when trying to use a non-existent factory as parent" do
@@ -66,8 +66,7 @@ describe "defining a factory" do
     @name    = :user
     @factory = "factory"
     @proxy   = "proxy"
-    stub(@factory).name { @name }
-    stub(@factory).aliases { [] }
+    stub(@factory).names { [@name] }
     @options = { :class => 'magic' }
     stub(FactoryGirl::Factory).new { @factory }
     stub(FactoryGirl::DefinitionProxy).new { @proxy }
@@ -88,21 +87,16 @@ describe "defining a factory" do
 
   it "should add the factory to the list of factories" do
     Factory.define(@name) {|f| }
-    @factory.should == FactoryGirl.factories[@name]
-  end
-
-  it "should allow a factory to be found by name" do
-    Factory.define(@name) {|f| }
-    FactoryGirl.factory_by_name(@name).should == @factory
+    @factory.should == FactoryGirl.find(@name)
   end
 end
 
 describe "after defining a factory" do
   before do
     @name    = :user
-    @factory = "factory"
+    @factory = FactoryGirl::Factory.new(@name)
 
-    FactoryGirl.factories[@name] = @factory
+    FactoryGirl.register(@factory)
   end
 
   it "should use Proxy::AttributesFor for Factory.attributes_for" do
@@ -152,33 +146,33 @@ end
 
 describe "defining a sequence" do
   before do
-    @sequence = "sequence"
     @name     = :count
+    @sequence = FactoryGirl::Sequence.new(@name) {}
     stub(FactoryGirl::Sequence).new { @sequence }
   end
 
   it "should create a new sequence" do
-    mock(FactoryGirl::Sequence).new(1) { @sequence }
+    mock(FactoryGirl::Sequence).new(@name, 1) { @sequence }
     Factory.sequence(@name)
   end
 
   it "should use the supplied block as the sequence generator" do
-    stub(FactoryGirl::Sequence).new.yields(1)
+    stub(FactoryGirl::Sequence).new { @sequence }.yields(1)
     yielded = false
     Factory.sequence(@name) {|n| yielded = true }
     (yielded).should be
   end
 
   it "should use the supplied start_value as the sequence start_value" do
-    mock(FactoryGirl::Sequence).new("A") { @sequence }
+    mock(FactoryGirl::Sequence).new(@name, "A") { @sequence }
     Factory.sequence(@name, "A")
   end
 end
 
 describe "after defining a sequence" do
   before do
-    @sequence = "sequence"
     @name     = :test
+    @sequence = FactoryGirl::Sequence.new(@name) {}
     @value    = '1 2 5'
 
     stub(@sequence).next { @value }

spec/factory_girl/attribute/dynamic_spec.rb

@@ -45,7 +45,7 @@ describe FactoryGirl::Attribute::Dynamic do
   end
 
   it "should raise an error when returning a sequence" do
-    stub(Factory).sequence { FactoryGirl::Sequence.new }
+    stub(Factory).sequence { FactoryGirl::Sequence.new(:email) }
     block = lambda { Factory.sequence(:email) }
     attr = FactoryGirl::Attribute::Dynamic.new(:email, block)
     proxy = stub!.set.subject

spec/factory_girl/definition_proxy_spec.rb

@@ -39,12 +39,12 @@ describe FactoryGirl::DefinitionProxy do
 
   describe "adding an attribute using a in-line sequence" do
     it "should create the sequence" do
-      mock(FactoryGirl::Sequence).new(1)
+      mock(FactoryGirl::Sequence).new(:name, 1)
       subject.sequence(:name) {}
     end
 
     it "should create the sequence with a custom default value" do
-      mock(FactoryGirl::Sequence).new("A")
+      mock(FactoryGirl::Sequence).new(:name, "A")
       subject.sequence(:name, "A") {}
     end
 
@@ -113,6 +113,7 @@ describe FactoryGirl::DefinitionProxy do
 
   it "adds an association when passed an undefined method without arguments or a block" do
     name = :user
+    FactoryGirl.register(FactoryGirl::Factory.new(name))
     attr = 'attribute'
     stub(attr).name { name }
     mock(FactoryGirl::Attribute::Association).new(name, name, {}) { attr }
@@ -122,12 +123,12 @@ describe FactoryGirl::DefinitionProxy do
 
   it "adds a sequence when passed an undefined method without arguments or a block" do
     name = :airport
-    proxy = 'proxy'
-    FactoryGirl.sequences[name] = FactoryGirl::Sequence.new { |value| "expected" }
+    FactoryGirl.register(FactoryGirl::Sequence.new(name))
+    attr = 'attribute'
+    stub(attr).name { name }
+    mock(FactoryGirl::Attribute::Association).new(name, name, {}) { attr }
     subject.send(name)
-    stub(proxy).set
-    factory.attributes.last.add_to(proxy)
-    proxy.should have_received.set(name, 'expected')
+    factory.attributes.should include(attr)
   end
 
   it "delegates to_create" do

spec/factory_girl/factory_spec.rb

@@ -1,33 +1,5 @@
 require 'spec_helper'
 
-describe FactoryGirl::Factory, "registering a factory" do
-  before do
-    @name    = :user
-    @factory = "factory"
-    @aliases = [:one, :two]
-    stub(@factory).name { @name }
-    stub(@factory).aliases { @aliases }
-  end
-
-  it "should add the factory to the list of factories" do
-    FactoryGirl.register_factory(@factory)
-    FactoryGirl.factory_by_name(@name).should == @factory
-  end
-
-  it "should not allow a duplicate factory definition" do
-    lambda {
-      2.times { FactoryGirl.register_factory(@factory) }
-    }.should raise_error(FactoryGirl::DuplicateDefinitionError)
-  end
-
-  it "registers aliases" do
-    FactoryGirl.register_factory(@factory)
-    @aliases.each do |name|
-      FactoryGirl.factory_by_name(name).should == @factory
-    end
-  end
-end
-
 describe FactoryGirl::Factory do
   include DefinesConstants
 
@@ -313,32 +285,6 @@ describe FactoryGirl::Factory, "with a string for a name" do
   end
 end
 
-describe FactoryGirl::Factory, "registered with a string name" do
-  before do
-    @name    = :string
-    @factory = FactoryGirl::Factory.new(@name)
-    FactoryGirl.register_factory(@factory)
-  end
-
-  it "should store the factory using a symbol" do
-    FactoryGirl.factories[@name].should == @factory
-  end
-end
-
-describe FactoryGirl::Factory, "registered with a custom name" do
-  before do
-    @actual_name = :string
-    @custom_name = :words
-    @factory = FactoryGirl::Factory.new(@actual_name)
-
-    FactoryGirl.register_factory(@factory, :as => @custom_name)
-  end
-
-  it "finds the factory using the custom name" do
-    FactoryGirl.factory_by_name(@custom_name).should == @factory
-  end
-end
-
 describe FactoryGirl::Factory, "for namespaced class" do
   include DefinesConstants
 
@@ -417,8 +363,9 @@ end
 
 describe FactoryGirl::Factory, "with aliases" do
   it "registers the aliases" do
+    name = :user
     aliased_name = :guest
-    factory = FactoryGirl::Factory.new("user", :aliases => [aliased_name])
-    factory.aliases.should == [aliased_name]
+    factory = FactoryGirl::Factory.new(:user, :aliases => [aliased_name])
+    factory.names.should =~ [name, aliased_name]
   end
 end

spec/factory_girl/proxy/build_spec.rb

@@ -21,7 +21,7 @@ describe FactoryGirl::Proxy::Build do
     before do
       @association = "associated-instance"
       @associated_factory = "associated-factory"
-      stub(FactoryGirl).factory_by_name { @associated_factory }
+      stub(FactoryGirl).find { @associated_factory }
       stub(@associated_factory).run { @association }
       @overrides = { 'attr' => 'value' }
       @proxy.associate(:owner, :user, @overrides)
@@ -39,7 +39,7 @@ describe FactoryGirl::Proxy::Build do
   it "should run create when building an association" do
     association = "associated-instance"
     associated_factory = "associated-factory"
-    stub(FactoryGirl).factory_by_name { associated_factory }
+    stub(FactoryGirl).find { associated_factory }
     stub(associated_factory).run { association }
     overrides = { 'attr' => 'value' }
     @proxy.association(:user, overrides).should == association

spec/factory_girl/proxy/create_spec.rb

@@ -22,7 +22,7 @@ describe FactoryGirl::Proxy::Create do
     before do
       @association = "associated-instance"
       @associated_factory = "associated-factory"
-      stub(FactoryGirl).factory_by_name { @associated_factory }
+      stub(FactoryGirl).find { @associated_factory }
       stub(@associated_factory).run { @association }
       @overrides = { 'attr' => 'value' }
       @proxy.associate(:owner, :user, @overrides)
@@ -40,7 +40,7 @@ describe FactoryGirl::Proxy::Create do
   it "should run create when building an association" do
     association = "associated-instance"
     associated_factory = "associated-factory"
-    stub(FactoryGirl).factory_by_name { associated_factory }
+    stub(FactoryGirl).find { associated_factory }
     stub(associated_factory).run { association }
     overrides = { 'attr' => 'value' }
     @proxy.association(:user, overrides).should == association

spec/factory_girl/proxy/stub_spec.rb

@@ -23,7 +23,7 @@ describe FactoryGirl::Proxy::Stub do
   describe "when a user factory exists" do
     before do
       @user = "user"
-      stub(FactoryGirl).factory_by_name { @associated_factory }
+      stub(FactoryGirl).find { @associated_factory }
       @associated_factory = 'associate-factory'
     end
 

spec/factory_girl/registry_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe FactoryGirl::Registry do
+  let(:factory) { FactoryGirl::Factory.new(:object) }
+
+  subject { FactoryGirl::Registry.new }
+
+  it "finds a registered a factory" do
+    subject.add(factory)
+    subject.find(factory.name).should == factory
+  end
+
+  it "raises when finding an unregistered factory" do
+    expect { subject.find(:bogus) }.to raise_error(ArgumentError)
+  end
+
+  it "adds and returns a factory" do
+    subject.add(factory).should == factory
+  end
+
+  it "knows that a factory is registered by symbol" do
+    subject.add(factory)
+    subject.should be_registered(factory.name.to_sym)
+  end
+
+  it "knows that a factory is registered by string" do
+    subject.add(factory)
+    subject.should be_registered(factory.name.to_s)
+  end
+
+  it "knows that a factory isn't registered" do
+    subject.should_not be_registered("bogus")
+  end
+
+  it "can be accessed like a hash" do
+    subject.add(factory)
+    subject[factory.name].should == factory
+  end
+
+  it "iterates registered factories" do
+    other_factory = FactoryGirl::Factory.new(:string)
+    subject.add(factory)
+    subject.add(other_factory)
+    result = {}
+
+    subject.each do |name, value|
+      result[name] = value
+    end
+
+    result.should == { factory.name       => factory,
+                       other_factory.name => other_factory }
+  end
+
+  it "registers an sequence" do
+    sequence = FactoryGirl::Sequence.new(:email) { |n| "somebody#{n}@example.com" }
+    subject.add(sequence)
+    subject.find(:email).should == sequence
+  end
+
+  it "doesn't allow a duplicate name" do
+    expect { 2.times { subject.add(factory) } }.
+      to raise_error(FactoryGirl::DuplicateDefinitionError)
+  end
+
+  it "registers aliases" do
+    aliases = [:thing, :widget]
+    factory = FactoryGirl::Factory.new(:object, :aliases => aliases)
+    subject.add(factory)
+    aliases.each do |name|
+      subject.find(name).should == factory
+    end
+  end
+
+  context "on the FactoryGirl module" do
+    it "finds a registered a factory" do
+      FactoryGirl.register(factory)
+      FactoryGirl.find(factory.name).should == factory
+    end
+
+    it "knows that a factory is registered by symbol" do
+      FactoryGirl.register(factory)
+      FactoryGirl.should be_registered(factory.name.to_sym)
+    end
+
+    it "sets the registry" do
+      registry = FactoryGirl::Registry.new
+      FactoryGirl.registry = registry
+      FactoryGirl.registry.should == registry
+    end
+  end
+end
+

spec/factory_girl/sequence_spec.rb

@@ -3,80 +3,97 @@ require 'spec_helper'
 describe FactoryGirl::Sequence do
   describe "a basic sequence" do
     before do
-      @sequence = FactoryGirl::Sequence.new {|n| "=#{n}" }
+      @name = :test
+      @sequence = FactoryGirl::Sequence.new(@name) {|n| "=#{n}" }
+    end
+
+    it "has names" do
+      @sequence.names.should == [@name]
     end
 
     it "should start with a value of 1" do
+      @sequence.run.should == "=1"
+    end
+
+    it "responds to next" do
       @sequence.next.should == "=1"
     end
 
+    it "responds to default_strategy" do
+      @sequence.default_strategy.should == :create
+    end
+
+    it "runs compatible with the Factory interface" do
+      @sequence.run(nil, nil).should == "=1"
+    end
+
     describe "after being called" do
       before do
-        @sequence.next
+        @sequence.run
       end
 
       it "should use the next value" do
-        @sequence.next.should == "=2"
+        @sequence.run.should == "=2"
       end
     end
   end
-  
+
   describe "a custom sequence" do
     before do
-      @sequence = FactoryGirl::Sequence.new("A") {|n| "=#{n}" }
+      @sequence = FactoryGirl::Sequence.new(:name, "A") {|n| "=#{n}" }
     end
 
     it "should start with a value of A" do
-      @sequence.next.should == "=A"
+      @sequence.run.should == "=A"
     end
 
     describe "after being called" do
       before do
-        @sequence.next
+        @sequence.run
       end
 
       it "should use the next value" do
-        @sequence.next.should == "=B"
+        @sequence.run.should == "=B"
       end
     end
   end
 
   describe "a basic sequence without a block" do
     before do
-      @sequence = FactoryGirl::Sequence.new
+      @sequence = FactoryGirl::Sequence.new(:name)
     end
-    
+
     it "should start with a value of 1" do
-      @sequence.next.should == 1
+      @sequence.run.should == 1
     end
-    
+
     describe "after being called" do
       before do
-        @sequence.next
+        @sequence.run
       end
 
       it "should use the next value" do
-        @sequence.next.should == 2
+        @sequence.run.should == 2
       end
     end
   end
 
   describe "a custom sequence without a block" do
     before do
-      @sequence = FactoryGirl::Sequence.new("A")
+      @sequence = FactoryGirl::Sequence.new(:name, "A")
     end
 
     it "should start with a value of A" do
-      @sequence.next.should == "A"
+      @sequence.run.should == "A"
     end
 
     describe "after being called" do
       before do
-        @sequence.next
+        @sequence.run
       end
 
       it "should use the next value" do
-        @sequence.next.should == "B"
+        @sequence.run.should == "B"
       end
     end
   end

spec/spec_helper.rb

@@ -22,8 +22,7 @@ RSpec.configure do |config|
   config.mock_framework = :rr
   RSpec::Core::ExampleGroup.send(:include, RR::Adapters::Rspec)
   config.after do
-    FactoryGirl.factories.clear
-    FactoryGirl.sequences.clear
+    FactoryGirl.registry = FactoryGirl::Registry.new
   end
 end