factory_girl 2.3.2 → 2.4.0

data/lib/factory_girl/evaluator_class_definer.rb

@@ -0,0 +1,34 @@
+module FactoryGirl
+  class EvaluatorClassDefiner
+    def initialize(attributes, callbacks, parent_class)
+      @parent_class = parent_class
+      @callbacks    = callbacks
+      @attributes   = attributes
+
+      attributes.each do |attribute|
+        define_attribute(attribute.name, attribute.to_proc)
+      end
+    end
+
+    def evaluator_class
+      @evaluator_class ||= Class.new(@parent_class).tap do |klass|
+        klass.callbacks ||= []
+        klass.callbacks += @callbacks
+        klass.attribute_lists ||= []
+        klass.attribute_lists += [@attributes]
+      end
+    end
+
+    private
+
+    def define_attribute(attribute_name, attribute_proc)
+      evaluator_class.send(:define_method, attribute_name) do
+        if @cached_attributes.key?(attribute_name)
+          @cached_attributes[attribute_name]
+        else
+          @cached_attributes[attribute_name] = instance_exec(&attribute_proc)
+        end
+      end
+    end
+  end
+end

data/lib/factory_girl/factory.rb

@@ -13,6 +13,7 @@ module FactoryGirl
       @class_name       = options[:class]
       @default_strategy = options[:default_strategy]
       @definition       = Definition.new(@name)
+      @compiled         = false
 
       inherit_traits(options[:traits] || [])
     end
@@ -26,25 +27,27 @@ module FactoryGirl
     end
 
     def build_class #:nodoc:
-      class_name.to_s.camelize.constantize
+      @build_class ||= if class_name.is_a? Class
+        class_name
+      else
+        class_name.to_s.camelize.constantize
+      end
     end
 
     def default_strategy #:nodoc:
-      @default_strategy || parent.default_strategy || :create
+      @default_strategy || parent.default_strategy
     end
 
     def run(proxy_class, overrides, &block) #:nodoc:
       block ||= lambda {|result| result }
+      compile
 
-      runner_options = {
-        :attributes  => attributes,
-        :callbacks   => callbacks,
-        :to_create   => to_create,
-        :build_class => build_class,
-        :proxy_class => proxy_class
-      }
+      proxy = proxy_class.new
 
-      block[Runner.new(runner_options).run(overrides)]
+      evaluator = evaluator_class.new(proxy, overrides.symbolize_keys)
+      attribute_assigner = AttributeAssigner.new(build_class, evaluator)
+
+      proxy.result(attribute_assigner, to_create).tap(&block)
     end
 
     def human_names
@@ -52,7 +55,7 @@ module FactoryGirl
     end
 
     def associations
-      attributes.select {|attribute| attribute.association? }
+      attributes.associations
     end
 
     # Names for this factory, including aliases.
@@ -85,9 +88,12 @@ module FactoryGirl
     end
 
     def compile
-      parent.defined_traits.each {|trait| define_trait(trait) }
-      parent.compile
-      @definition.compile
+      unless @compiled
+        parent.defined_traits.each {|trait| define_trait(trait) }
+        parent.compile
+        @definition.compile
+        @compiled = true
+      end
     end
 
     def with_traits(traits)
@@ -102,24 +108,29 @@ module FactoryGirl
       @class_name || parent.class_name || name
     end
 
+    def evaluator_class
+      @evaluator_class ||= EvaluatorClassDefiner.new(attributes, callbacks, parent.evaluator_class).evaluator_class
+    end
+
     def attributes
       compile
       AttributeList.new(@name).tap do |list|
-        traits.each do |trait|
-          list.apply_attributes(trait.attributes)
+        processing_order.each do |factory|
+          list.apply_attributes factory.attributes
         end
-
-        list.apply_attributes(@definition.attributes)
-        list.apply_attributes(parent.attributes)
       end
     end
 
     def callbacks
-      [parent.callbacks, traits.map(&:callbacks).reverse, @definition.callbacks].flatten
+      processing_order.map {|factory| factory.callbacks }.flatten
     end
 
     private
 
+    def processing_order
+      [traits.reverse, @definition].flatten
+    end
+
     def assert_valid_options(options)
       options.assert_valid_keys(:class, :parent, :default_strategy, :aliases, :traits)
 
@@ -142,65 +153,5 @@ module FactoryGirl
       super
       @definition = @definition.clone
     end
-
-    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
-
-      def run(overrides = {})
-        @overrides = overrides.symbolize_keys
-
-        apply_attributes
-        apply_remaining_overrides
-
-        proxy.result(@to_create)
-      end
-
-      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
-
-      def apply_remaining_overrides
-        @overrides.each { |attr, val| add_static_attribute(attr, val) }
-      end
-
-      def overrides_for_attribute(attribute)
-        @overrides.select { |attr, val| attribute.alias_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

data/lib/factory_girl/null_factory.rb

@@ -9,7 +9,8 @@ module FactoryGirl
     delegate :defined_traits, :callbacks, :attributes, :to => :definition
 
     def compile; end
-    def default_strategy; end
     def class_name; end
+    def default_strategy; :create; end
+    def evaluator_class; FactoryGirl::Evaluator; end
   end
 end

data/lib/factory_girl/null_object.rb

@@ -0,0 +1,19 @@
+module FactoryGirl
+  if defined?(::BasicObject)
+    class NullObject < ::BasicObject
+      def method_missing(*args)
+        nil
+      end
+    end
+  else
+    class NullObject
+      instance_methods.each do |m|
+        undef_method(m) if m.to_s !~ /(?:^__|^nil\?$|^send$|^object_id$)/
+      end
+
+      def method_missing(*args)
+        nil
+      end
+    end
+  end
+end

data/lib/factory_girl/proxy.rb

@@ -3,23 +3,11 @@ require "factory_girl/proxy/build"
 require "factory_girl/proxy/create"
 require "factory_girl/proxy/attributes_for"
 require "factory_girl/proxy/stub"
+require "observer"
 
 module FactoryGirl
   class Proxy #:nodoc:
-    def initialize(klass, callbacks = [])
-      @callbacks = process_callbacks(callbacks)
-      @proxy     = ObjectWrapper.new(klass)
-    end
-
-    delegate :get, :set, :set_ignored, :to => :@proxy
-
-    def run_callbacks(name)
-      if @callbacks[name]
-        @callbacks[name].each do |callback|
-          callback.run(result_instance, self)
-        end
-      end
-    end
+    include Observable
 
     # Generates an association using the current build strategy.
     #
@@ -56,7 +44,7 @@ module FactoryGirl
     def association(name, overrides = {})
     end
 
-    def result(to_create)
+    def result(attribute_assigner, to_create)
       raise NotImplementedError, "Strategies must return a result"
     end
 
@@ -68,78 +56,9 @@ module FactoryGirl
 
     private
 
-    def method_missing(method, *args, &block)
-      get(method)
-    end
-
-    def process_callbacks(callbacks)
-      callbacks.inject({}) do |result, callback|
-        result[callback.name] ||= []
-        result[callback.name] << callback
-        result
-      end
-    end
-
-    def result_instance
-      @proxy.object
-    end
-
-    def result_hash
-      @proxy.to_hash
-    end
-
-    class ObjectWrapper
-      def initialize(klass)
-        @klass      = klass
-        @attributes = []
-        @cached_attribute_values = {}
-      end
-
-      def to_hash
-        @attributes.inject({}) do |result, attribute|
-          result[attribute] = get(attribute)
-          result
-        end
-      end
-
-      def object
-        @object ||= @klass.new
-        assign_object_attributes
-        @object
-      end
-
-      def set(attribute, value)
-        define_attribute(attribute, value)
-        @attributes << attribute.name
-      end
-
-      def set_ignored(attribute, value)
-        define_attribute(attribute, value)
-      end
-
-      def get(attribute)
-        @cached_attribute_values[attribute] ||= anonymous_instance.send(attribute)
-      end
-
-      private
-
-      def define_attribute(attribute, value)
-        anonymous_class.send(:define_method, attribute.name, value)
-      end
-
-      def assign_object_attributes
-        (@attributes - @cached_attribute_values.keys).each do |attribute|
-          @object.send("#{attribute}=", get(attribute))
-        end
-      end
-
-      def anonymous_class
-        @anonymous_class ||= Class.new
-      end
-
-      def anonymous_instance
-        @anonymous_instance ||= anonymous_class.new
-      end
+    def run_callbacks(name, result_instance)
+      changed
+      notify_observers(name, result_instance)
     end
   end
 end

data/lib/factory_girl/proxy/attributes_for.rb

@@ -1,13 +1,8 @@
 module FactoryGirl
   class Proxy #:nodoc:
     class AttributesFor < Proxy #:nodoc:
-      def set(attribute, value)
-        return if attribute.is_a? Attribute::Association
-        super
-      end
-
-      def result(to_create)
-        result_hash
+      def result(attribute_assigner, to_create)
+        attribute_assigner.hash
       end
     end
   end

data/lib/factory_girl/proxy/build.rb

@@ -6,9 +6,10 @@ module FactoryGirl
         factory.run(get_method(overrides[:method]), overrides.except(:method))
       end
 
-      def result(to_create)
-        run_callbacks(:after_build)
-        result_instance
+      def result(attribute_assigner, to_create)
+        attribute_assigner.object.tap do |result_instance|
+          run_callbacks(:after_build, result_instance)
+        end
       end
 
       private

data/lib/factory_girl/proxy/create.rb

@@ -1,13 +1,12 @@
 module FactoryGirl
   class Proxy #:nodoc:
     class Create < Build #:nodoc:
-      def result(to_create)
-        super
-
-        to_create[result_instance]
-
-        run_callbacks(:after_create)
-        result_instance
+      def result(attribute_assigner, to_create)
+        attribute_assigner.object.tap do |result_instance|
+          run_callbacks(:after_build, result_instance)
+          to_create[result_instance]
+          run_callbacks(:after_create, result_instance)
+        end
       end
     end
   end

data/lib/factory_girl/proxy/stub.rb

@@ -3,8 +3,25 @@ module FactoryGirl
     class Stub < Proxy #:nodoc:
       @@next_id = 1000
 
-      def initialize(klass, callbacks = [])
-        super
+      def association(factory_name, overrides = {})
+        factory = FactoryGirl.factory_by_name(factory_name)
+        factory.run(Proxy::Stub, overrides.except(:method))
+      end
+
+      def result(attribute_assigner, to_create)
+        attribute_assigner.object.tap do |result_instance|
+          stub_database_interaction_on_result(result_instance)
+          run_callbacks(:after_stub, result_instance)
+        end
+      end
+
+      private
+
+      def next_id
+        @@next_id += 1
+      end
+
+      def stub_database_interaction_on_result(result_instance)
         result_instance.id = next_id
         result_instance.instance_eval do
           def persisted?
@@ -40,22 +57,6 @@ module FactoryGirl
           end
         end
       end
-
-      def association(factory_name, overrides = {})
-        factory = FactoryGirl.factory_by_name(factory_name)
-        factory.run(Proxy::Stub, overrides.except(:method))
-      end
-
-      def result(to_create)
-        run_callbacks(:after_stub)
-        result_instance
-      end
-
-      private
-
-      def next_id
-        @@next_id += 1
-      end
     end
   end
 end