factory_girl 2.5.2 → 2.6.0

data/.travis.yml

@@ -7,7 +7,6 @@ before_install:
   - gem update --system
 script: "bundle exec rake spec:unit spec:acceptance features"
 gemfile:
-  - gemfiles/2.1.gemfile
   - gemfiles/2.3.gemfile
   - gemfiles/3.0.gemfile
   - gemfiles/3.1.gemfile

data/Changelog

@@ -1,3 +1,9 @@
+2.6.0 (February 17, 2012)
+  Improve documentation of has_many associations in the GETTING_STARTED
+    document
+  Deprecate :method in favor of :strategy when overriding an association's
+    build strategy
+
 2.5.2 (February 10, 2012)
   Fix step definitions to use associations defined in parent factories
   Add inline trait support to (build|create)_list

data/GETTING_STARTED.md

@@ -165,7 +165,7 @@ end
 Dependent Attributes
 --------------------
 
-Attributes can be based on the values of other attributes using the proxy that is yielded to lazy attribute blocks:
+Attributes can be based on the values of other attributes using the evaluator that is yielded to lazy attribute blocks:
 
 ```ruby
 factory :user do
@@ -193,8 +193,8 @@ factory :user do
   name  { "John Doe#{" - Rockstar" if rockstar}" }
   email { "#{name.downcase}@example.com" }
 
-  after_create do |user, proxy|
-    user.name.upcase! if proxy.upcased
+  after_create do |user, evaluator|
+    user.name.upcase! if evaluator.upcased
   end
 end
 
@@ -207,8 +207,8 @@ within attributes\_for and won't be set on the model, even if the attribute
 exists or you attempt to override it.
 
 Within Factory Girl's dynamic attributes, you can access ignored attributes as
-you would expect. If you need to access the proxy in a Factory Girl callback,
-you'll need to declare a second block argument (for the proxy) and access
+you would expect. If you need to access the evaluator in a Factory Girl callback,
+you'll need to declare a second block argument (for the evaluator) and access
 ignored attributes from there.
 
 Associations
@@ -246,12 +246,12 @@ post.new_record?        # => true
 post.author.new_record? # => false
 ```
 
-To not save the associated object, specify :method => :build in the factory:
+To not save the associated object, specify :strategy => :build in the factory:
 
 ```ruby
 factory :post do
   # ...
-  association :author, :factory => :user, :method => :build
+  association :author, :factory => :user, :strategy => :build
 end
 
 # Builds a User, and then builds a Post, but does not save either
@@ -260,6 +260,51 @@ post.new_record?        # => true
 post.author.new_record? # => true
 ```
 
+Generating data for a `has_many` relationship is a bit more involved,
+depending on the amount of flexibility desired, but here's a surefire example
+of generating associated data.
+
+```ruby
+FactoryGirl.define do
+
+  # post factory with a `belongs_to` association for the user
+  factory :post do
+    title "Through the Looking Glass"
+    user
+  end
+
+  # user factory without associated posts
+  factory :user do
+    name "John Doe"
+
+    # user_with_posts will create post data after the user has been created
+    factory :user_with_posts do
+      # posts_count is declared as an ignored attribute and available in
+      # attributes on the factory, as well as the callback via the evaluator
+      ignore do
+        posts_count 5
+      end
+
+      # the after_create yields two values; the user instance itself and the
+      # evaluator, which stores all values from the factory, including ignored
+      # attributes; `create_list`'s second argument is the number of records
+      # to create and we make sure the user is associated properly to the post
+      after_create do |user, evaluator|
+        FactoryGirl.create_list(:post, evaluator.posts_count, :user => user)
+      end
+    end
+  end
+end
+```
+
+This allows us to do:
+
+```ruby
+FactoryGirl.create(:user).posts.length # 0
+FactoryGirl.create(:user_with_posts).posts.length # 5
+FactoryGirl.create(:user_with_posts, :posts_count => 15).posts.length # 15
+```
+
 Inheritance
 -----------
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    factory_girl (2.5.2)
+    factory_girl (2.6.0)
       activesupport (>= 2.3.9)
 
 GEM

data/gemfiles/2.3.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /Users/joshuaclayton/dev/gems/factory_girl
   specs:
-    factory_girl (2.5.2)
+    factory_girl (2.6.0)
       activesupport (>= 2.3.9)
 
 GEM

data/gemfiles/3.0.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /Users/joshuaclayton/dev/gems/factory_girl
   specs:
-    factory_girl (2.5.2)
+    factory_girl (2.6.0)
       activesupport (>= 2.3.9)
 
 GEM

data/gemfiles/3.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /Users/joshuaclayton/dev/gems/factory_girl
   specs:
-    factory_girl (2.5.2)
+    factory_girl (2.6.0)
       activesupport (>= 2.3.9)
 
 GEM

data/gemfiles/3.2.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /Users/joshuaclayton/dev/gems/factory_girl
   specs:
-    factory_girl (2.5.2)
+    factory_girl (2.6.0)
       activesupport (>= 2.3.9)
 
 GEM

data/lib/factory_girl.rb

@@ -1,7 +1,8 @@
 require "active_support/core_ext/module/delegation"
 
 require 'factory_girl/errors'
-require 'factory_girl/proxy'
+require 'factory_girl/association_runner'
+require 'factory_girl/strategy'
 require 'factory_girl/registry'
 require 'factory_girl/null_factory'
 require 'factory_girl/null_object'

data/lib/factory_girl/association_runner.rb

@@ -0,0 +1,50 @@
+module FactoryGirl
+  class AssociationRunner
+    def initialize(factory_name, strategy_name_or_object, overrides)
+      @factory_name            = factory_name
+      @strategy_name_or_object = strategy_name_or_object
+      @overrides               = overrides
+    end
+
+    def run(strategy_override = nil)
+      strategy_name_or_object = strategy_override || @strategy_name_or_object
+      strategy = StrategyCalculator.new(strategy_name_or_object).strategy
+      factory.run(strategy, @overrides)
+    end
+
+    private
+
+    def factory
+      FactoryGirl.factory_by_name(@factory_name)
+    end
+
+    class StrategyCalculator
+      def initialize(name_or_object)
+        @name_or_object = name_or_object
+      end
+
+      def strategy
+        if strategy_is_object?
+          @name_or_object
+        else
+          strategy_name_to_object
+        end
+      end
+
+      private
+
+      def strategy_is_object?
+        @name_or_object.is_a?(Class) && @name_or_object.ancestors.include?(::FactoryGirl::Strategy)
+      end
+
+      def strategy_name_to_object
+        case @name_or_object
+        when :build  then Strategy::Build
+        when :create then Strategy::Create
+        when nil     then Strategy::Create
+        else raise "unrecognized method #{@name_or_object}"
+        end
+      end
+    end
+  end
+end

data/lib/factory_girl/definition_proxy.rb

@@ -22,7 +22,7 @@ module FactoryGirl
     # instance is generated. Lazy attribute blocks will not be called if that
     # attribute is overridden for a specific instance.
     #
-    # When defining lazy attributes, an instance of FactoryGirl::Proxy will
+    # When defining lazy attributes, an instance of FactoryGirl::Strategy will
     # be yielded, allowing associations to be built using the correct build
     # strategy.
     #

data/lib/factory_girl/evaluator.rb

@@ -1,3 +1,4 @@
+require "active_support/core_ext/hash/except"
 require "active_support/core_ext/class/attribute"
 
 module FactoryGirl
@@ -29,7 +30,17 @@ module FactoryGirl
       @build_strategy.add_observer(CallbackRunner.new(self.class.callbacks, self))
     end
 
-    delegate :association, :to => :@build_strategy
+    def association(factory_name, overrides = {})
+      build_strategy = if overrides.has_key?(:method)
+                         $stderr.puts "DEPRECATION WARNING: using :method to specify a build strategy is deprecated; use :strategy instead"
+                         overrides[:method]
+                       elsif overrides.has_key?(:strategy)
+                         overrides[:strategy]
+                       end
+
+      runner = AssociationRunner.new(factory_name, build_strategy, overrides.except(:method, :strategy))
+      @build_strategy.association(runner)
+    end
 
     def instance=(object_instance)
       @instance = object_instance

data/lib/factory_girl/factory.rb

@@ -36,16 +36,16 @@ module FactoryGirl
       @default_strategy || parent.default_strategy
     end
 
-    def run(proxy_class, overrides, &block) #:nodoc:
+    def run(strategy_class, overrides, &block) #:nodoc:
       block ||= lambda {|result| result }
       compile
 
-      proxy = proxy_class.new
+      strategy = strategy_class.new
 
-      evaluator = evaluator_class.new(proxy, overrides.symbolize_keys)
+      evaluator = evaluator_class.new(strategy, overrides.symbolize_keys)
       attribute_assigner = AttributeAssigner.new(evaluator, &instance_builder)
 
-      proxy.result(attribute_assigner, to_create).tap(&block)
+      strategy.result(attribute_assigner, to_create).tap(&block)
     end
 
     def human_names
@@ -133,7 +133,7 @@ module FactoryGirl
       options.assert_valid_keys(:class, :parent, :default_strategy, :aliases, :traits)
 
       if options[:default_strategy]
-        Proxy.ensure_strategy_exists!(options[:default_strategy])
+        Strategy.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

data/lib/factory_girl/strategy.rb

@@ -0,0 +1,32 @@
+require "factory_girl/strategy/build"
+require "factory_girl/strategy/create"
+require "factory_girl/strategy/attributes_for"
+require "factory_girl/strategy/stub"
+require "observer"
+
+module FactoryGirl
+  class Strategy #:nodoc:
+    include Observable
+
+    def association(runner)
+      raise NotImplementedError, "Strategies must return an association"
+    end
+
+    def result(attribute_assigner, to_create)
+      raise NotImplementedError, "Strategies must return a result"
+    end
+
+    def self.ensure_strategy_exists!(strategy)
+      unless Strategy.const_defined? strategy.to_s.camelize
+        raise ArgumentError, "Unknown strategy: #{strategy}"
+      end
+    end
+
+    private
+
+    def run_callbacks(name, result_instance)
+      changed
+      notify_observers(name, result_instance)
+    end
+  end
+end

data/lib/factory_girl/{proxy → strategy}/attributes_for.rb

@@ -1,6 +1,9 @@
 module FactoryGirl
-  class Proxy #:nodoc:
-    class AttributesFor < Proxy #:nodoc:
+  class Strategy #:nodoc:
+    class AttributesFor < Strategy #:nodoc:
+      def association(runner)
+      end
+
       def result(attribute_assigner, to_create)
         attribute_assigner.hash
       end

data/lib/factory_girl/strategy/build.rb

@@ -0,0 +1,15 @@
+module FactoryGirl
+  class Strategy #:nodoc:
+    class Build < Strategy #:nodoc:
+      def association(runner)
+        runner.run
+      end
+
+      def result(attribute_assigner, to_create)
+        attribute_assigner.object.tap do |result_instance|
+          run_callbacks(:after_build, result_instance)
+        end
+      end
+    end
+  end
+end

data/lib/factory_girl/{proxy → strategy}/create.rb

@@ -1,6 +1,10 @@
 module FactoryGirl
-  class Proxy #:nodoc:
-    class Create < Build #:nodoc:
+  class Strategy #:nodoc:
+    class Create < Strategy #:nodoc:
+      def association(runner)
+        runner.run
+      end
+
       def result(attribute_assigner, to_create)
         attribute_assigner.object.tap do |result_instance|
           run_callbacks(:after_build, result_instance)

data/lib/factory_girl/{proxy → strategy}/stub.rb

@@ -1,11 +1,10 @@
 module FactoryGirl
-  class Proxy
-    class Stub < Proxy #:nodoc:
+  class Strategy
+    class Stub < Strategy #:nodoc:
       @@next_id = 1000
 
-      def association(factory_name, overrides = {})
-        factory = FactoryGirl.factory_by_name(factory_name)
-        factory.run(Proxy::Stub, overrides.except(:method))
+      def association(runner)
+        runner.run(Strategy::Stub)
       end
 
       def result(attribute_assigner, to_create)

data/lib/factory_girl/syntax/generate.rb

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

data/lib/factory_girl/syntax/make.rb

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

data/lib/factory_girl/syntax/methods.rb

@@ -18,7 +18,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, *traits_and_overrides, &block)
-        run_factory_girl_proxy(name, traits_and_overrides, Proxy::AttributesFor, &block)
+        run_factory_girl_strategy(name, traits_and_overrides, Strategy::AttributesFor, &block)
       end
 
       # Generates and returns an instance from this factory. Attributes can be
@@ -37,7 +37,7 @@ module FactoryGirl
       # An instance of the class this factory generates, with generated attributes
       # assigned.
       def build(name, *traits_and_overrides, &block)
-        run_factory_girl_proxy(name, traits_and_overrides, Proxy::Build, &block)
+        run_factory_girl_strategy(name, traits_and_overrides, Strategy::Build, &block)
       end
 
       # Generates, saves, and returns an instance from this factory. Attributes can
@@ -60,7 +60,7 @@ module FactoryGirl
       # A saved instance of the class this factory generates, with generated
       # attributes assigned.
       def create(name, *traits_and_overrides, &block)
-        run_factory_girl_proxy(name, traits_and_overrides, Proxy::Create, &block)
+        run_factory_girl_strategy(name, traits_and_overrides, Strategy::Create, &block)
       end
 
       # Generates and returns an object with all attributes from this factory
@@ -79,7 +79,7 @@ module FactoryGirl
       # Returns: +Object+
       # An object with generated attributes stubbed out.
       def build_stubbed(name, *traits_and_overrides, &block)
-        run_factory_girl_proxy(name, traits_and_overrides, Proxy::Stub, &block)
+        run_factory_girl_strategy(name, traits_and_overrides, Strategy::Stub, &block)
       end
 
       # Builds and returns multiple instances from this factory as an array. Attributes can be
@@ -134,7 +134,7 @@ module FactoryGirl
 
       private
 
-      def run_factory_girl_proxy(name, traits_and_overrides, proxy, &block)
+      def run_factory_girl_strategy(name, traits_and_overrides, strategy, &block)
         overrides = if traits_and_overrides.last.respond_to?(:has_key?)
                       traits_and_overrides.pop
                     else
@@ -147,7 +147,7 @@ module FactoryGirl
           factory = factory.with_traits(traits_and_overrides)
         end
 
-        factory.run(proxy, overrides, &block)
+        factory.run(strategy, overrides, &block)
       end
     end
   end