factory_girl 2.1.0 → 2.1.2

data/lib/factory_girl/declaration/implicit.rb

@@ -0,0 +1,23 @@
+module FactoryGirl
+  class Declaration
+    class Implicit < Declaration
+      def initialize(name, factory = nil)
+        super(name)
+        @factory = factory
+      end
+
+      private
+
+      def build
+        if FactoryGirl.factories.registered?(name)
+          [Attribute::Association.new(name, name, {})]
+        elsif FactoryGirl.sequences.registered?(name)
+          [Attribute::Sequence.new(name, name)]
+        else
+          trait_root = @factory || FactoryGirl
+          trait_root.trait_by_name(name).attributes.to_a
+        end
+      end
+    end
+  end
+end

data/lib/factory_girl/declaration/static.rb

@@ -0,0 +1,16 @@
+module FactoryGirl
+  class Declaration
+    class Static < Declaration
+      def initialize(name, value)
+        super(name)
+        @value = value
+      end
+
+      private
+
+      def build
+        [Attribute::Static.new(name, @value)]
+      end
+    end
+  end
+end

data/lib/factory_girl/definition_proxy.rb

@@ -36,13 +36,14 @@ module FactoryGirl
         if value
           raise AttributeDefinitionError, "Both value and block given"
         else
-          attribute = Attribute::Dynamic.new(name, block)
+          declaration = Declaration::Dynamic.new(name, block)
         end
       else
-        attribute = Attribute::Static.new(name, value)
+        declaration = FactoryGirl::Declaration::Static.new(name, value)
       end
 
-      @factory.define_attribute(attribute)
+      @factory.declare_attribute(declaration)
+      declaration
     end
 
     # Calls add_attribute using the missing method name as the name of the
@@ -78,7 +79,7 @@ module FactoryGirl
     # are equivalent.
     def method_missing(name, *args, &block)
       if args.empty? && block.nil?
-        @factory.define_attribute(Attribute::Implicit.new(name, @factory))
+        @factory.declare_attribute(Declaration::Implicit.new(name, @factory))
       elsif args.first.is_a?(Hash) && args.first.has_key?(:factory)
         association(name, *args)
       else
@@ -131,8 +132,7 @@ module FactoryGirl
     #    name of the factory. For example, a "user" association will by
     #    default use the "user" factory.
     def association(name, options = {})
-      factory_name = options.delete(:factory) || name
-      @factory.define_attribute(Attribute::Association.new(name, factory_name, options))
+      @factory.declare_attribute(Declaration::Association.new(name, options))
     end
 
     def after_build(&block)

data/lib/factory_girl/factory.rb

@@ -1,3 +1,6 @@
+require "active_support/core_ext/hash/keys"
+require "active_support/inflector"
+
 module FactoryGirl
   # Raised when a factory is defined that attempts to instantiate itself.
   class AssociationDefinitionError < RuntimeError
@@ -13,7 +16,6 @@ module FactoryGirl
 
   class Factory
     attr_reader :name #:nodoc:
-    attr_reader :traits #:nodoc:
 
     def factory_name
       puts "WARNING: factory.factory_name is deprecated. Use factory.name instead."
@@ -25,7 +27,7 @@ module FactoryGirl
     end
 
     def build_class #:nodoc:
-      @build_class ||= class_for(class_name)
+      @build_class ||= class_name.to_s.camelize.constantize
     end
 
     def default_strategy #:nodoc:
@@ -34,18 +36,19 @@ module FactoryGirl
 
     def initialize(name, options = {}) #:nodoc:
       assert_valid_options(options)
-      @name                     = factory_name_for(name)
-      @parent                   = options[:parent]
-      @options                  = options
-      @traits                   = []
-      @children                 = []
-      @attribute_list           = AttributeList.new
-      @inherited_attribute_list = AttributeList.new
+      @name           = name.to_s.underscore.to_sym
+      @parent         = options[:parent]
+      @parent_factory = nil
+      @options        = options
+      @defined_traits = []
+      @traits         = []
+      @children       = []
+      @attribute_list = AttributeList.new
+      @compiled       = false
     end
 
     def allow_overrides
       @attribute_list.overridable
-      @inherited_attribute_list.overridable
       self
     end
 
@@ -53,56 +56,48 @@ module FactoryGirl
       @attribute_list.overridable?
     end
 
-    def inherit_from(parent) #:nodoc:
+    def inherit_factory(parent) #:nodoc:
       @options[:class]            ||= parent.class_name
       @options[:default_strategy] ||= parent.default_strategy
 
       allow_overrides if parent.allow_overrides?
       parent.add_child(self)
 
-      @inherited_attribute_list.apply_attributes(parent.attributes)
+      @parent_factory = parent
     end
 
     def add_child(factory)
       @children << factory unless @children.include?(factory)
     end
 
-    def apply_traits(traits) #:nodoc:
-      traits.reverse.map { |name| trait_by_name(name) }.each do |trait|
-        apply_attributes(trait.attributes)
-      end
-    end
-
-    def apply_attributes(attributes_to_apply)
-      @attribute_list.apply_attributes(attributes_to_apply)
-    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}'"
-      end
-
-      @attribute_list.define_attribute(attribute).tap { update_children }
+    def inherit_traits(traits)
+      @traits = traits
     end
 
     def define_trait(trait)
-      @traits << trait
+      @defined_traits << trait
     end
 
     def add_callback(name, &block)
-      @attribute_list.add_callback(name, &block)
+      @attribute_list.add_callback(Callback.new(name, block))
     end
 
     def attributes
+      ensure_compiled
       AttributeList.new.tap do |list|
+        @traits.reverse.map { |name| trait_by_name(name) }.each do |trait|
+          list.apply_attributes(trait.attributes)
+        end
+
         list.apply_attributes(@attribute_list)
-        list.apply_attributes(@inherited_attribute_list)
-      end.to_a
+        list.apply_attributes(@parent_factory.attributes) if @parent_factory
+      end
     end
 
     def run(proxy_class, overrides) #:nodoc:
       proxy = proxy_class.new(build_class)
-      overrides = symbolize_keys(overrides)
+      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) }
@@ -117,7 +112,7 @@ module FactoryGirl
     end
 
     def human_names
-      names.map {|name| name.to_s.gsub('_', ' ') }
+      names.map {|name| name.to_s.humanize.downcase }
     end
 
     def associations
@@ -167,36 +162,45 @@ module FactoryGirl
       @to_create_block = block
     end
 
-    private
-
-    def update_children
-      @children.each { |child| child.inherit_from(self) }
+    def callbacks
+      attributes.callbacks
     end
 
-    def class_for (class_or_to_s)
-      if class_or_to_s.respond_to?(:to_sym)
-        class_name = variable_name_to_class_name(class_or_to_s)
-        class_name.split('::').inject(Object) do |object, string|
-          object.const_get(string)
+    def compile
+      declarations.each do |declaration|
+        declaration.to_attributes.each do |attribute|
+          define_attribute(attribute)
         end
-      else
-        class_or_to_s
       end
+      @compiled = true
     end
 
-    def factory_name_for(class_or_to_s)
-      if class_or_to_s.respond_to?(:to_sym)
-        class_or_to_s.to_sym
-      else
-        class_name_to_variable_name(class_or_to_s).to_sym
+    def declare_attribute(declaration)
+      @attribute_list.declare_attribute(declaration)
+    end
+
+    private
+
+    def declarations
+      @attribute_list.declarations
+    end
+
+    def update_children
+      @children.each { |child| child.inherit_factory(self) }
+    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}'"
       end
+
+      @attribute_list.define_attribute(attribute)
+      update_children if allow_overrides?
     end
 
     def assert_valid_options(options)
-      invalid_keys = options.keys - [:class, :parent, :default_strategy, :aliases, :traits]
-      unless invalid_keys == []
-        raise ArgumentError, "Unknown arguments: #{invalid_keys.inspect}"
-      end
+      options.assert_valid_keys(:class, :parent, :default_strategy, :aliases, :traits)
+
       if options[:default_strategy]
         assert_valid_strategy(options[:default_strategy])
         puts "WARNING: default_strategy is deprecated."
@@ -205,37 +209,17 @@ module FactoryGirl
     end
 
     def assert_valid_strategy(strategy)
-      unless Proxy.const_defined? variable_name_to_class_name(strategy)
+      unless Proxy.const_defined? strategy.to_s.camelize
         raise ArgumentError, "Unknown strategy: #{strategy}"
       end
     end
 
-    # Based on ActiveSupport's underscore inflector
-    def class_name_to_variable_name(name)
-      name.to_s.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
-    end
-
-    # Based on ActiveSupport's camelize inflector
-    def variable_name_to_class_name(name)
-      name.to_s.
-        gsub(/\/(.?)/) { "::#{$1.upcase}" }.
-        gsub(/(?:^|_)(.)/) { $1.upcase }
-    end
-
-    # From ActiveSupport
-    def symbolize_keys(hash)
-      hash.inject({}) do |options, (key, value)|
-        options[(key.to_sym rescue key) || key] = value
-        options
-      end
+    def trait_for(name)
+      @defined_traits.detect {|trait| trait.name == name }
     end
 
-    def trait_for(name)
-      traits.detect {|trait| trait.name == name }
+    def ensure_compiled
+      compile unless @compiled
     end
   end
 end

data/lib/factory_girl/proxy.rb

@@ -4,6 +4,7 @@ module FactoryGirl
     attr_reader :callbacks
 
     def initialize(klass)
+      @callbacks = {}
     end
 
     def get(attribute)
@@ -15,20 +16,15 @@ module FactoryGirl
     def associate(name, factory, attributes)
     end
 
-    def add_callback(name, block)
-      @callbacks ||= {}
-      @callbacks[name] ||= []
-      @callbacks[name] << block
+    def add_callback(callback)
+      @callbacks[callback.name] ||= []
+      @callbacks[callback.name] << callback
     end
 
     def run_callbacks(name)
-      if @callbacks && @callbacks[name]
-        @callbacks[name].each do |block|
-          case block.arity
-          when 0 then block.call
-          when 2 then block.call(@instance, self)
-          else block.call(@instance)
-          end
+      if @callbacks[name]
+        @callbacks[name].each do |callback|
+          callback.run(@instance, self)
         end
       end
     end

data/lib/factory_girl/proxy/attributes_for.rb

@@ -2,6 +2,7 @@ module FactoryGirl
   class Proxy #:nodoc:
     class AttributesFor < Proxy #:nodoc:
       def initialize(klass)
+        super(klass)
         @hash = {}
         @ignored_attributes = {}
       end

data/lib/factory_girl/proxy/build.rb

@@ -2,6 +2,7 @@ module FactoryGirl
   class Proxy #:nodoc:
     class Build < Proxy #:nodoc:
       def initialize(klass)
+        super(klass)
         @instance = klass.new
         @ignored_attributes = {}
       end

data/lib/factory_girl/proxy/stub.rb

@@ -4,6 +4,7 @@ module FactoryGirl
       @@next_id = 1000
 
       def initialize(klass)
+        super(klass)
         @instance = klass.new
         @ignored_attributes = {}
         @instance.id = next_id

data/lib/factory_girl/syntax/default.rb

@@ -22,12 +22,13 @@ module FactoryGirl
           proxy.instance_eval(&block) if block_given?
 
           if traits = options.delete(:traits)
-            factory.apply_traits(traits)
+            factory.inherit_traits(traits)
           end
 
           if parent = options.delete(:parent)
-            factory.inherit_from(FactoryGirl.factory_by_name(parent))
+            factory.inherit_factory(FactoryGirl.factory_by_name(parent))
           end
+
           FactoryGirl.register_factory(factory)
 
           proxy.child_factories.each do |(child_name, child_options, child_block)|
@@ -53,6 +54,7 @@ module FactoryGirl
           factory = FactoryGirl.factory_by_name(name).allow_overrides
           proxy = FactoryGirl::DefinitionProxy.new(factory)
           proxy.instance_eval(&block)
+          factory.compile
         end
       end
     end

data/lib/factory_girl/syntax/vintage.rb

@@ -29,7 +29,7 @@ module FactoryGirl
           proxy = FactoryGirl::DefinitionProxy.new(factory)
           yield(proxy)
           if parent = options.delete(:parent)
-            factory.inherit_from(FactoryGirl.factory_by_name(parent))
+            factory.inherit_factory(FactoryGirl.factory_by_name(parent))
           end
           FactoryGirl.register_factory(factory)
         end

data/lib/factory_girl/trait.rb

@@ -10,16 +10,24 @@ module FactoryGirl
       proxy.instance_eval(&block) if block_given?
     end
 
-    def define_attribute(attribute)
-      @attribute_list.define_attribute(attribute)
+    def declare_attribute(declaration)
+      @attribute_list.declare_attribute(declaration)
+      declaration
     end
 
     def add_callback(name, &block)
-      @attribute_list.add_callback(name, &block)
+      @attribute_list.add_callback(Callback.new(name, block))
     end
 
     def attributes
-      @attribute_list.to_a
+      AttributeList.new.tap do |list|
+        @attribute_list.declarations.each do |declaration|
+          declaration.to_attributes.each do |attribute|
+            list.define_attribute(attribute)
+          end
+        end
+        list.apply_attributes @attribute_list
+      end
     end
 
     def names

data/lib/factory_girl/version.rb

@@ -1,4 +1,4 @@
 module FactoryGirl
-  VERSION = "2.1.0"
+  VERSION = "2.1.2"
 end