gabrielg-factory_girl 1.1.9 → 1.2.0

data/README.textile

@@ -117,6 +117,19 @@ end</code></pre>
 If the factory name is the same as the association name, the factory name can
 be left out.
 
+h2. Multiple associations
+
+If a factory specifies a :count on an association definition, it's considered
+to be a collection of objects. For example:
+
+<pre><code># This will create 2 associated posts on the author
+Factory.define :post do |p|
+  p.title "Hello world"
+end
+
+Factory.define :author do |a|
+  a.association :posts, :count => 2
+end</code></pre>
 
 h2. Sequences
 
@@ -135,6 +148,48 @@ Factory.next :email
 Factory.next :email
 # => "person2@example.com"</code></pre>
 
+h2. Callbacks
+
+Callbacks can be specified after build and after create. If the block arity is
+greater than 1, the callback block will receive the instance of the created/built
+object, and the attributes used to build it. If the block arity is 1 the callback
+will just receive the instance of the object. For example:
+
+<pre><code>
+Factory.define :post do |p|
+  p.author "joe"
+  p.after_build do |post, attrs|
+    # post will be an instance of Post
+    # attrs will be {:author => "joe"}
+  end
+end
+
+Factory.define :user do |u|
+  u.name "john"
+  p.after_create do |user|
+    # user will be an instance of User
+  end
+end</code></pre>
+
+h2. Inheritance
+
+Factories can be inherited from each other by specifying the :inherit option when
+defining a factory. For example:
+
+<pre><code>
+Factory.define :user do |u|
+  u.name "John Doe"
+  u.role "user"
+end
+
+Factory.define :admin_user, :inherit => :user do |u|
+  u.role "admin"
+end
+
+user = Factory(:admin_user)
+user.name # => "John Doe"
+user.role # => "admin"
+</code></pre>
 
 h2. Using factories
 

data/lib/factory_girl/factory.rb

@@ -139,7 +139,7 @@ class Factory
     instance.save!
     if callback = @callbacks[:after_create]
       params = (callback.arity > 1) ? [instance, final_attrs] : [instance]
-      instance_exec(*params, &callback)
+      callback.call(*params)
     end
     instance
   end
@@ -263,7 +263,7 @@ class Factory
     end
     if callback = @callbacks[:after_build]
       params = (callback.arity > 1) ? [instance, attrs] : [instance]
-      instance_exec(*params, &callback)
+      callback.call(*params)
     end
     [instance, attrs]
   end

data/test/factory_test.rb

@@ -437,46 +437,44 @@ class FactoryTest < Test::Unit::TestCase
       end
 
       context "and an after_build callback has been registered" do
-        saved = nil
-        setup do
-          @the_block = lambda {|user| assert user.new_record?; saved = user}
 
+        setup do
+          @the_block = lambda {|user| assert user.new_record?; @saved = user}
           @factory.after_build &@the_block
         end
 
         should "call the callback when the object is built" do
-          @factory.expects(:instance_exec)
+          @the_block.expects(:call)
           @factory.build
         end
 
         should "call the callback when the object is created" do
-          @factory.expects(:instance_exec)
+          @the_block.expects(:call)
           @factory.create
         end
 
         should "yield the instance to block if block arity is <= 1" do
-          @factory.after_build(&(lambda{|user|}))
-          @factory.expects(:instance_exec).with(anything)
+          @the_block.expects(:call).with(anything)
           @factory.build
         end
 
         should "yield the instance and attrs to block if block arity is > 1" do
-          @factory.after_build(&(lambda{|user,attrs|}))
-          @factory.expects(:instance_exec).with(anything, instance_of(Hash))
+          the_block = lambda {|user,attrs|}
+          @factory.after_build &the_block
+          the_block.expects(:call).with(anything, instance_of(Hash))
           @factory.build
         end
 
         should "yield the instance to the callback when called" do
           instance = @factory.build
-          assert_equal saved, instance
+          assert_equal @saved, instance
         end
       end
 
       context "and an after_create callback has been registered" do
-        saved = nil
-        setup do
-          @the_block = lambda {|user| assert !user.new_record?; saved = user}
 
+        setup do
+          @the_block = lambda {|user| assert !user.new_record?; @saved = user}
           @factory.after_create &@the_block
         end
 
@@ -486,61 +484,60 @@ class FactoryTest < Test::Unit::TestCase
         end
 
         should "call the callback when the object is created" do
-          @factory.expects(:instance_exec)
+          @the_block.expects(:call).with(anything)
           @factory.create
         end
 
         should "yield the instance to block if block arity is <= 1" do
-          @factory.after_create(&(lambda{|user|}))
-          @factory.expects(:instance_exec).with(anything)
+          @the_block.expects(:call).with(anything)
           @factory.create
         end
 
         should "yield the instance and attrs to block if block arity is > 1" do
-          @factory.after_create(&(lambda{|user,attrs|}))
-          @factory.expects(:instance_exec).with(anything, instance_of(Hash))
+          the_block = lambda {|user,attrs|}
+          @factory.after_create &the_block
+          the_block.expects(:call).with(anything, instance_of(Hash))
           @factory.create
         end
 
         should "yield the instance to the callback when called" do
           instance = @factory.create
-          assert_equal saved, instance
+          assert_equal @saved, instance
         end
       end
 
       context "and both after_build and after_create callbacks have been registered" do
-        post_build, = post_create = nil
+
         setup do
-          test = self
-          @the_after_build_block = lambda {|user| test.assert(user.new_record?); post_build = user}
-          @the_after_create_block = lambda {|user| test.assert(!user.new_record?); post_create = user}
+          @the_after_build_block = lambda {|user| assert(user.new_record?); @post_build = user}
+          @the_after_create_block = lambda {|user| assert(!user.new_record?); @post_create = user}
 
           @factory.after_build &@the_after_build_block
           @factory.after_create &@the_after_create_block
         end
 
         should "only call the after_build callback when the object is built" do
-          @factory.expects(:instance_exec).once
+          @the_after_build_block.expects(:call).once
           @factory.build
         end
 
         should "call both callbacks when the object is created" do
-          @factory.expects(:instance_exec).at_least(2)
+          @the_after_build_block.expects(:call).once
+          @the_after_create_block.expects(:call).once
           @factory.create
         end
 
         should "yield the same instance to each callback when called" do
           instance = @factory.create
-          assert_equal post_build, instance
-          assert_equal post_create, instance
-          assert_equal post_create, post_build
+          assert_equal @post_build, instance
+          assert_equal @post_create, instance
+          assert_equal @post_create, @post_build
         end
 
         should "call the after_build callback before the after_create callback when objects are created" do
           # TODO - is this good enough to detect "beforeness"?
-          test = self
-          @the_after_build_block = lambda {|user| test.assert_nil @post_build; test.assert_nil @post_create; @post_build = user}
-          @the_after_create_block = lambda {|user| test.assert_not_nil @post_build; test.assert_nil @post_create; @post_create = user}
+          @the_after_build_block = lambda {|user| assert_nil @post_build; assert_nil @post_create; @post_build = user}
+          @the_after_create_block = lambda {|user| assert_not_nil @post_build; assert_nil @post_create; @post_create = user}
 
           @factory.after_build &@the_after_build_block
           @factory.after_create &@the_after_create_block

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gabrielg-factory_girl
 version: !ruby/object:Gem::Version 
-  version: 1.1.9
+  version: 1.2.0
 platform: ruby
 authors: 
 - Joe Ferris