factory_girl 2.2.0 → 2.3.0

data/lib/factory_girl/declaration/dynamic.rb

@@ -6,6 +6,15 @@ module FactoryGirl
         @block = block
       end
 
+      def ==(other)
+        name == other.name &&
+          ignored == other.ignored &&
+          block == other.block
+      end
+
+      protected
+      attr_reader :block
+
       private
 
       def build

data/lib/factory_girl/declaration/implicit.rb

@@ -6,6 +6,15 @@ module FactoryGirl
         @factory = factory
       end
 
+      def ==(other)
+        name == other.name &&
+          factory == other.factory &&
+          ignored == other.ignored
+      end
+
+      protected
+      attr_reader :factory
+
       private
 
       def build
@@ -14,8 +23,8 @@ module FactoryGirl
         elsif FactoryGirl.sequences.registered?(name)
           [Attribute::Sequence.new(name, name, @ignored)]
         else
-          trait_root = @factory || FactoryGirl
-          trait_root.trait_by_name(name).attributes.to_a
+          @factory.inherit_traits([name])
+          []
         end
       end
     end

data/lib/factory_girl/declaration/static.rb

@@ -6,6 +6,15 @@ module FactoryGirl
         @value = value
       end
 
+      def ==(other)
+        name == other.name &&
+          value == other.value &&
+          ignored == other.ignored
+      end
+
+      protected
+      attr_reader :value
+
       private
 
       def build

data/lib/factory_girl/declaration_list.rb

@@ -0,0 +1,48 @@
+module FactoryGirl
+  class DeclarationList
+    include Enumerable
+
+    def initialize(name = nil)
+      @declarations = []
+      @name         = name
+      @overridable  = false
+    end
+
+    def declare_attribute(declaration)
+      delete_declaration(declaration) if overridable?
+
+      @declarations << declaration
+      declaration
+    end
+
+    def overridable
+      @overridable = true
+    end
+
+    def attribute_list
+      AttributeList.new(@name).tap do |list|
+        to_attributes.each do |attribute|
+          list.define_attribute(attribute)
+        end
+      end
+    end
+
+    def each(&block)
+      @declarations.each(&block)
+    end
+
+    private
+
+    def delete_declaration(declaration)
+      @declarations.delete_if {|decl| decl.name == declaration.name }
+    end
+
+    def to_attributes
+      @declarations.inject([]) {|result, declaration| result += declaration.to_attributes }
+    end
+
+    def overridable?
+      @overridable
+    end
+  end
+end

data/lib/factory_girl/definition.rb

@@ -0,0 +1,62 @@
+module FactoryGirl
+  class Definition
+    attr_reader :callbacks, :defined_traits, :declarations
+
+    def initialize(name = nil)
+      @declarations   = DeclarationList.new(name)
+      @callbacks      = []
+      @defined_traits = []
+      @to_create      = nil
+      @traits         = []
+    end
+
+    delegate :declare_attribute, :to => :declarations
+
+    def attributes
+      @attributes ||= declarations.attribute_list
+    end
+
+    def compile
+      attributes
+    end
+
+    def overridable
+      declarations.overridable
+      self
+    end
+
+    def traits
+      @traits.reverse.map { |name| trait_by_name(name) }
+    end
+
+    def inherit_traits(new_traits)
+      @traits += new_traits
+    end
+
+    def add_callback(callback)
+      @callbacks << callback
+    end
+
+    def to_create(&block)
+      if block_given?
+        @to_create = block
+      else
+        @to_create
+      end
+    end
+
+    def define_trait(trait)
+      @defined_traits << trait
+    end
+
+    private
+
+    def trait_by_name(name)
+      trait_for(name) || FactoryGirl.trait_by_name(name)
+    end
+
+    def trait_for(name)
+      defined_traits.detect {|trait| trait.name == name }
+    end
+  end
+end

data/lib/factory_girl/definition_proxy.rb

@@ -8,8 +8,8 @@ module FactoryGirl
 
     attr_reader :child_factories
 
-    def initialize(factory, ignore = false)
-      @factory         = factory
+    def initialize(definition, ignore = false)
+      @definition      = definition
       @ignore          = ignore
       @child_factories = []
     end
@@ -41,11 +41,11 @@ module FactoryGirl
         Declaration::Static.new(name, value, @ignore)
       end
 
-      @factory.declare_attribute(declaration)
+      @definition.declare_attribute(declaration)
     end
 
     def ignore(&block)
-      proxy = DefinitionProxy.new(@factory, true)
+      proxy = DefinitionProxy.new(@definition, true)
       proxy.instance_eval(&block)
     end
 
@@ -82,7 +82,7 @@ module FactoryGirl
     # are equivalent.
     def method_missing(name, *args, &block)
       if args.empty? && block.nil?
-        @factory.declare_attribute(Declaration::Implicit.new(name, @factory, @ignore))
+        @definition.declare_attribute(Declaration::Implicit.new(name, @definition, @ignore))
       elsif args.first.is_a?(Hash) && args.first.has_key?(:factory)
         association(name, *args)
       else
@@ -135,23 +135,23 @@ module FactoryGirl
     #    name of the factory. For example, a "user" association will by
     #    default use the "user" factory.
     def association(name, options = {})
-      @factory.declare_attribute(Declaration::Association.new(name, options))
+      @definition.declare_attribute(Declaration::Association.new(name, options))
     end
 
     def after_build(&block)
-      @factory.add_callback(:after_build, &block)
+      @definition.add_callback(Callback.new(:after_build, block))
     end
 
     def after_create(&block)
-      @factory.add_callback(:after_create, &block)
+      @definition.add_callback(Callback.new(:after_create, block))
     end
 
     def after_stub(&block)
-      @factory.add_callback(:after_stub, &block)
+      @definition.add_callback(Callback.new(:after_stub, block))
     end
 
     def to_create(&block)
-      @factory.to_create(&block)
+      @definition.to_create(&block)
     end
 
     def factory(name, options = {}, &block)
@@ -159,7 +159,7 @@ module FactoryGirl
     end
 
     def trait(name, &block)
-      @factory.define_trait(Trait.new(name, &block))
+      @definition.define_trait(Trait.new(name, &block))
     end
   end
 end

data/lib/factory_girl/factory.rb

@@ -3,76 +3,46 @@ require "active_support/inflector"
 
 module FactoryGirl
   class Factory
-    attr_reader :name #:nodoc:
+    attr_reader :name, :definition #:nodoc:
 
     def initialize(name, options = {}) #:nodoc:
       assert_valid_options(options)
-      @name             = name.to_s.underscore.to_sym
+      @name             = name.is_a?(Symbol) ? name : name.to_s.underscore.to_sym
       @parent           = options[:parent]
       @aliases          = options[:aliases] || []
-      @traits           = options[:traits]  || []
       @class_name       = options[:class]
       @default_strategy = options[:default_strategy]
-      @defined_traits   = []
-      @attribute_list   = AttributeList.new
-      @compiled         = false
+      @definition       = Definition.new(@name)
+
+      inherit_traits(options[:traits] || [])
     end
 
+    delegate :add_callback, :declare_attribute, :to_create, :define_trait,
+             :defined_traits, :traits, :inherit_traits, :to => :@definition
+
     def factory_name
       $stderr.puts "DEPRECATION WARNING: factory.factory_name is deprecated; use factory.name instead."
       name
     end
 
     def build_class #:nodoc:
-      @build_class ||= class_name.to_s.camelize.constantize
+      class_name.to_s.camelize.constantize
     end
 
     def default_strategy #:nodoc:
-      @default_strategy || (parent && parent.default_strategy) || :create
-    end
-
-    def allow_overrides
-      @compiled = false
-      @attribute_list.overridable
-      self
-    end
-
-    def allow_overrides?
-      @attribute_list.overridable?
-    end
-
-    def define_trait(trait)
-      @defined_traits << trait
-    end
-
-    def add_callback(name, &block)
-      @attribute_list.add_callback(Callback.new(name, block))
+      @default_strategy || parent.default_strategy || :create
     end
 
     def run(proxy_class, overrides, &block) #:nodoc:
-      ensure_compiled
-      proxy = proxy_class.new(build_class)
-      callbacks.each { |callback| proxy.add_callback(callback) }
-      overrides = overrides.symbolize_keys
-
-      attributes.each do |attribute|
-        factory_overrides = overrides.select { |attr, val| attribute.aliases_for?(attr) }
-        if factory_overrides.empty?
-          attribute.add_to(proxy)
-        else
-          factory_overrides.each do |attr, val|
-            if attribute.ignored
-              proxy.set_ignored(attr, val)
-            else
-              proxy.set(attr, val)
-            end
-
-            overrides.delete(attr)
-          end
-        end
-      end
-      overrides.each { |attr, val| proxy.set(attr, val) }
-      result = proxy.result(@to_create_block)
+      runner_options = {
+        :attributes  => attributes,
+        :callbacks   => callbacks,
+        :to_create   => to_create,
+        :build_class => build_class,
+        :proxy_class => proxy_class
+      }
+
+      result = Runner.new(runner_options).run(overrides)
 
       block ? block.call(result) : result
     end
@@ -85,16 +55,6 @@ module FactoryGirl
       attributes.select {|attribute| attribute.association? }
     end
 
-    def trait_by_name(name)
-      if existing_attribute = trait_for(name)
-        existing_attribute
-      elsif parent
-        parent.trait_by_name(name)
-      else
-        FactoryGirl.trait_by_name(name)
-      end
-    end
-
     # Names for this factory, including aliases.
     #
     # Example:
@@ -124,94 +84,123 @@ module FactoryGirl
       [name] + @aliases
     end
 
-    def to_create(&block)
-      @to_create_block = block
-    end
-
-    def ensure_compiled
-      compile unless @compiled
+    def compile
+      parent.defined_traits.each {|trait| define_trait(trait) }
+      parent.compile
+      @definition.compile
     end
 
-    def declare_attribute(declaration)
-      @attribute_list.declare_attribute(declaration)
+    def with_traits(traits)
+      self.clone.tap do |factory_with_traits|
+        factory_with_traits.inherit_traits traits
+      end
     end
 
     protected
 
     def class_name #:nodoc:
-      @class_name || (parent && parent.class_name) || name
+      @class_name || parent.class_name || name
     end
 
     def attributes
-      ensure_compiled
-      AttributeList.new.tap do |list|
-        @traits.reverse.map { |name| trait_by_name(name) }.each do |trait|
+      compile
+      AttributeList.new(@name).tap do |list|
+        traits.each do |trait|
           list.apply_attributes(trait.attributes)
         end
 
-        list.apply_attributes(@attribute_list)
-        list.apply_attributes(parent.attributes) if parent
+        list.apply_attributes(@definition.attributes)
+        list.apply_attributes(parent.attributes)
       end
     end
 
-    private
-
     def callbacks
-      attributes.callbacks
+      [parent.callbacks, traits.map(&:callbacks), @definition.callbacks].flatten
     end
 
-    def compile
-      inherit_factory(parent) if parent
+    private
 
-      declarations.each do |declaration|
-        declaration.to_attributes.each do |attribute|
-          define_attribute(attribute)
-        end
-      end
+    def assert_valid_options(options)
+      options.assert_valid_keys(:class, :parent, :default_strategy, :aliases, :traits)
 
-      @compiled = true
+      if options[:default_strategy]
+        Proxy.ensure_strategy_exists!(options[:default_strategy])
+        $stderr.puts "DEPRECATION WARNING: default_strategy is deprecated."
+        $stderr.puts "Override to_create if you need to prevent a call to #save!."
+      end
     end
 
-    def inherit_factory(parent) #:nodoc:
-      parent.ensure_compiled
-      allow_overrides if parent.allow_overrides?
+    def parent
+      if @parent
+        FactoryGirl.factory_by_name(@parent)
+      else
+        NullFactory.new
+      end
     end
 
-    def declarations
-      @attribute_list.declarations
+    def initialize_copy(source)
+      super
+      @definition = @definition.clone
     end
 
-    def define_attribute(attribute)
-      if attribute.respond_to?(:factory) && attribute.factory == self.name
-        raise AssociationDefinitionError, "Self-referencing association '#{attribute.name}' in factory '#{self.name}'"
+    class Runner
+      def initialize(options = {})
+        @attributes  = options[:attributes]
+        @callbacks   = options[:callbacks]
+        @to_create   = options[:to_create]
+        @build_class = options[:build_class]
+        @proxy_class = options[:proxy_class]
+
+        @overrides   = {}
       end
 
-      @attribute_list.define_attribute(attribute)
-    end
+      def run(overrides = {})
+        @overrides = overrides.symbolize_keys
 
-    def assert_valid_options(options)
-      options.assert_valid_keys(:class, :parent, :default_strategy, :aliases, :traits)
+        apply_attributes
+        apply_remaining_overrides
 
-      if options[:default_strategy]
-        assert_valid_strategy(options[:default_strategy])
-        $stderr.puts "DEPRECATION WARNING: default_strategy is deprecated."
-        $stderr.puts "Override to_create if you need to prevent a call to #save!."
+        proxy.result(@to_create)
       end
-    end
 
-    def assert_valid_strategy(strategy)
-      unless Proxy.const_defined? strategy.to_s.camelize
-        raise ArgumentError, "Unknown strategy: #{strategy}"
+      private
+
+      def apply_attributes
+        @attributes.each do |attribute|
+          if overrides_for_attribute(attribute).any?
+            handle_attribute_with_overrides(attribute)
+          else
+            handle_attribute_without_overrides(attribute)
+          end
+        end
       end
-    end
 
-    def trait_for(name)
-      @defined_traits.detect {|trait| trait.name == name }
-    end
+      def apply_remaining_overrides
+        @overrides.each { |attr, val| add_static_attribute(attr, val) }
+      end
 
-    def parent
-      return unless @parent
-      FactoryGirl.factory_by_name(@parent)
+      def overrides_for_attribute(attribute)
+        @overrides.select { |attr, val| attribute.aliases_for?(attr) }
+      end
+
+      def handle_attribute_with_overrides(attribute)
+        overrides_for_attribute(attribute).each do |attr, val|
+          add_static_attribute(attr, val, attribute.ignored)
+          @overrides.delete(attr)
+        end
+      end
+
+      def add_static_attribute(attr, val, ignored = false)
+        Attribute::Static.new(attr, val, ignored).add_to(proxy)
+      end
+
+      def handle_attribute_without_overrides(attribute)
+        attribute.add_to(proxy)
+      end
+
+      def proxy
+        @proxy ||= @proxy_class.new(@build_class, @callbacks)
+      end
     end
   end
 end